第四天Java基础01（内部类、Obj、Data、Calendar、System、StringBuilder、iterator、泛型、斗地主）

1.成员内部类如何调用

1.如何new内部类
Outer.Inner name = new Outer().new Inner(）；
2.如何取Outer的变量
Outer.this.num

2.局部内部类如何调用

1.意思是在方法中定义的类，该类只能由该方法使用，超出方法不得使用。

3.类的权限修饰

1.外部类：public / （default）
2.成员内部类：public /protected / (default) / private
3.局部内部类：都不能写

4.匿名内部类

1.匿名内部类{}这样一种写法的类。
2.定义一个接口，然后直接new接口他就会出现这样一种效果

MyInterface obj = new MyInterface(){//此时这里面就是匿名内部类
	@Override
	public void mothed(){
		//System.out.prinln();
	}
}
obj.mothed();

5.发红包的两种方式

1.普通平均红包

public ArrayList<Integer> divide(int totalMoney, int totalCount) {
        ArrayList<Integer> arr = new ArrayList<>();
        int pj = totalMoney / totalCount;//平均值
        int ys = totalMoney % totalCount;//取余
        for (int i = 0 ; i < totalCount - 1 ; i++){
            arr.add(pj);
        }
        arr.add(pj+ys);
        return arr;
    }

2.随机红包

@Override
    public ArrayList<Integer> divide(int totalMoney, int totalCount) {
        ArrayList<Integer> arr = new ArrayList<>();
        Random rd = new Random();
        int leftMoni = totalMoney;
        int leftCoun = totalCount;
        for (int i = 0 ; i < totalCount -1; i++ ){
            int hb = 1+rd.nextInt(leftMoni/leftCoun*2);
            arr.add(hb);
            leftMoni -= hb;
            leftCoun--;
        }
        arr.add(leftMoni);
        return arr;
    }

6.Object中的方法

6.1 equals方法的重写

 @Override
    public boolean equals(Object o) {
        if (this == o) return true; //1.先判断地址是否相同
        if (o == null || getClass() != o.getClass()) return false; //2.判断类型是否相同
//        if(o instanceof Person){
//            Person person = (Person) o;
//            return Objects.equals(name, person.name) &&
//                    Objects.equals(age, person.age);
//        }
        Person person = (Person) o;
        return Objects.equals(name, person.name) &&
                Objects.equals(age, person.age);
    }

6.2Objects类中的equals方法，防止空指针异常

Objects.equals(obj,obj);//该方法还是比较地址值

7.Data类（日期类）

7.1日期和时间工具类，精确到毫秒。

7.2计算机中的毫秒。

1.时间原点：（0毫秒）1970 年 1 月 1 日 00:00:00（英国格林威治），
中国属于东八区，在这基础上加八个小时。所以中国的时间原点为
1970 年 1 月 1 日 08:00:00
2.毫秒和天的换算关系：2466*1000 = 86400,000 等于一天。

7.3Data类中的方法

new Data();//获取当前时间
new Data(0L);//毫秒日期
new Data().getTime();//当前日期到时间原点给的毫秒

7.4DataFormat

1.时间格式化输出：

SimpleDateFormat sdf = new SimpleDateFormat(yyyy-MM-dd  HH:mm:ss);
Date date = new Date();
System.out.println(sdf.format(data));

2.反输出

sdf.parse("2020年等等等等等");//该方法需要抛异常

8.Calendar类（日历类，取代Data）

 Calendar car = Calendar.getInstance();
        final int i = car.get(Calendar.YEAR);//年
        int i1 = car.get(Calendar.MONTH);//月，西方的月0到11，加1等于东方的月
        int i2 = car.get(Calendar.DATE);//月中的某一天
        int i3 = car.get(Calendar.DAY_OF_MONTH);//月中的某一天
        int i4 = car.get(Calendar.HOUR);//时
        int i5 = car.get(Calendar.MINUTE);//分
        int i6 = car.get(Calendar.SECOND);//秒

2.设置set（String s，int n）;

//使用set()方法
car.set(Calendar.YEAR,9999);//参数与上面一样

3.add()把指定的字段增加或减少

car.add(Calendar.YEAR,2);//参数与上面一样，在原来的基础上添加2年。

4.getTime(),返回Date

car.getTime();//把Calendar类转化为Data

9.System类（系统类）

1.currentTimeMillis();//返回系统毫秒时间
2.arrayCopy(原数组，原数组中起始位置，目标数组，目标数组起始位置，要复制的数量)

10.StringBuilder(类,字符串缓冲区)

1.StringBuilder底层也是用数组，没有被finel修饰，所以数组长度可累加，
初始长度为16，后面*2增加。
2.常用的方法有append()、toString()方法。
append()追加字符串、toString()方法把StringBuilder转化为String。

11.包装类

基本上基础类Java中都有自己的包装类

12.Collection（接口）集合

1.所有单列集合的顶层接口

12.1Collection中的常用功能（7个）

1.add(); //集合添加元素，返回值boolean
2.clear(); //清空所有元素
3.remove();//把给定的对象在当前集合中清除，返回值为boolean
4.contains();//看看里面是否包含给定元素，返回值为boolean
5.isEmpty();//判断集合是否为空，返回值为boolean
6.size();//集合的个数
7.toArray();//把集合转化为数组

13.iterator（迭代器）

1.集合中没有索引可以来取元素，所以要遍历元素可以通过迭代器。
2.迭代器通过集合中的iterator()方法来调用。

Collection<String> ce = new ArrayList<>();
        ce.add("迪丽热巴");
        ce.add("古力娜扎");
        ce.add("马儿扎哈");
        ce.add("降央卓玛");
        Iterator<String> iterator = ce.iterator();
        while(iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }

14.foreach

1.增强版的for循环，重要用来遍历集合和数组的。底层就是迭代器。

15.泛型

1.含有泛型类，new的时候，传递的是说什么类型就是什么类型。

public class<E> HelloWord{
	private <E> name;
	public void <E> getName(){
	}////////
}

2.含有泛型方法，调用的时候，传递的是什么类型就是什么类型。

public <M> void name(M m){
	System.out.println(m);
}

3.含有泛型接口，实现类实现接口的时候，传递的是什么类型就是什么类型。
4.泛型的通配符<?>
要求定义一个方法，打印所有类型的ArrayList集合

public void show(ArrayList<?> list){
	while(list.hasNext()){
		Object o = list.next();
		System.out.println(o);
	}
}

5.泛型通配符的高级使用：

public static void getElement2(Collection<? super Number> coll){
	//该泛型关键字为super意思是传递的泛型只能是Number本身或其父类
}
public static void getElement2(Collection<? extends Number> coll){
	//该泛型关键字为extends意思是传递的泛型只能是Number本身或其子类
}

斗地主小练习

package puke;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

/**
 * 准备牌
 * 1.定义一个集合放牌
 * 2.定义两个数组存放花色和牌号
 * 3.循环组合拼牌，然后放入集合中
 * 4.大王小王另外放入集合中
 * 洗牌
 * 5.使用Collections打乱集合
 * 发牌
 * 6.轮流发牌依照索引取模3可分为3种情况，0、1、2
 * 在发牌前先判断什么时候留底牌，最后三张为底牌，所以当索引大于等于51的时候给底牌发牌
 * 7.定义好四个集合存放
 */
public class puke {
    public static void main(String[] args) {
        List<String> puke = new ArrayList<>();
        String hua [] = {"♠","♣","❤","♦"};
        String number [] = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
        puke.add("大王");
        puke.add("小王");
        for (String str: hua) {
            for (String n: number) {
                puke.add(str+n);
            }
        }
        Collections.shuffle(puke);
        List<String> userOne = new ArrayList<>();
        List<String> userTow = new ArrayList<>();
        List<String> userThree = new ArrayList<>();
        List<String> diPai = new ArrayList<>();
        for (int i = 0; i < puke.size(); i++) {
            String p = puke.get(i);
            if(i>=51){
                diPai.add(p);
            }else if (i%3==0){
                userOne.add(p);
            }
            else if (i%3==1){
                userTow.add(p);
            }
            else if (i%3==2){
                userThree.add(p);
            }
        }
        System.out.println("一号的牌"+userOne);
        System.out.println("二号的牌"+userTow);
        System.out.println("三号的牌"+userThree);
        System.out.println("底牌牌"+diPai);

    }
}