Java基础加强

面向对象

public class **Object**类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

Object o1 = 1;
Object o2 = new Integer(1);
Object o3 = new int[1];
Object o4 = new Object[1];
Object[] o5 = new Object[1];
Object o6 = new Integer[1];

增强for循环

Can only iterate over an array or an instance of java.lang.Iterable

1. 数组
2. 实现了java.lang.Iterable接口的实例

class MyIterator implements Iterator<Object>{
        private int curIndex; //记录当前迭代到了哪个位置
        @Override
        public boolean hasNext() {
            return curIndex < index;
        }

        @Override
        public Object next() {

            return datas[curIndex++];
        }
    }

对象产生的

分配空间，对属性进行默认初始化

父类属性初始化

父类构造函数

子类属性初始化

子类构造函数被调用

class Person{
    int age = 100;
    Person(){
        this(36);
        print();
    }
    Person(int age){
        this.age = age;
    }
    public void print(){
        System.out.println(age);
    }
}
class SuperPerson extends Person{
    int age =200;
    SuperPerson(){
        this(12);
        if(age == 18);
            print();
    }
    SuperPerson(int age){
        this.age = age;
    }

    @Override
    public void print() {
        System.out.println(age);
    }
}

1.创建空间，默认初始化属性 0；
2.父类属性初始化  age = 100 
3.父类构造函数被调用 super.age = 36  this.age=0
4.子类属性初始化 this.age = 200;
5.子类构造函数被调用 this.age = 12;

对象是怎么被回收的

    public static void main(String[] args){
        Man man = new Man();
        man = null;

        System.gc();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

对象的克隆

1. 基本数据类型的拷贝，拷贝的是值
2. 引用数据类型的拷贝，拷贝的是地址

注意 clone() 方法是在Object中声明的，但是它的访问权限是 protected, 所以我们需要重写它，然后对它进行方法的覆盖

public class ObjectClone {

    public static void main(String[] args) {
        /*int[] aaa = {1,32,3,4,5,67};
        int[] bbb = aaa.clone();
        System.out.println(Arrays.toString(bbb));
        bbb[1] = 100;
        System.out.println(aaa[1]);*/

        //二维数组的拷贝
        /*int[] ccc[] = {{1,2,3},{4,5,6},{73,32}};
        int[][] ddd = ccc.clone();
        ddd[1][1] = 100;  //深拷贝， 浅拷贝
        System.out.println(ccc[1][1]);*/

        Cat cat = new Cat();
        try {
            Cat cloneCat = (Cat) cat.clone();
//          cloneCat.mouse = (Mouse) cat.mouse.clone();
            System.out.println(cloneCat.mouse.weight);
            cat.mouse.weight--;
            System.out.println(cloneCat.mouse.weight);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

class Cat implements Cloneable {
    Mouse mouse = new Mouse();
    int age = 10;
    //封装对象的拷贝
    @Override
    public Cat clone() throws CloneNotSupportedException {
        Cat cloneCat = (Cat) super.clone();
        cloneCat.mouse = (Mouse) this.mouse.clone();
        return cloneCat;
    }
}

class Mouse implements Cloneable {
    int weight = 2;
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

双色球

红球：1~··33

篮球： 1~ 16

while(sets.size() < 6){
  int random = (int) (Math.random()*33+1); // 0.0<=  <1.0  1<=r <34 
  sets.add(new MyNum("红球："+random));
}

hashCode : 无序

hashCode — > equals (不可重复，无序)

    @Override
    public boolean equals(Object obj) {
        if(obj instanceof MyNum){
            MyNum num = (MyNum) obj;
            return num.ball.equals(this.ball);
        }
        return false;
    }
    @Override
    public int hashCode() {
        return this.ball.hashCode();
    }

三人斗地主

1. 要有一副牌

   private void initPuke(){
        int index = 0;
        //4.把牌存起来
        for (int i = 0; i < 52; i++) {
            //1.确定花色
            char f = flower.charAt(i/13);
            //2.确定牌号
            int num = i%13 + 1; // 0~12  1-13
            //3.转化牌号 A ，J...
            switch (num) {
                case 1: //A
                    pukes[index++] = f+"A";
                    break;
                case 11: //J
                    pukes[index++] = f+"J";
                    break;
                case 12: //Q
                    pukes[index++] = f+"Q";
                    break;
                case 13: //K
                    pukes[index++] = f+"K";
                    break;
                default: //2~9
                    pukes[index++] = f+""+num;
                    break;
            }
        }
        pukes[index++]="小王";
        pukes[index++]="大王";
        print();
    }

1. 洗牌，发牌

1. 随机取一个数
2. 根据这个随机数，取到对应的牌
3. 将牌的总量减少
4. 将取到的牌后面所有的牌往前移动一位

    /**
     * 随机取牌
     */
    public String getPuke(){
        int random = (int) (Math.random()*pukeCount); // 0<= <54
        String puke = pukes[random];
        pukeCount--;

        for (int i = random; i < pukeCount; i++) {
            pukes[i] = pukes[i+1];
        }

        return puke;
    }

1. 三个玩家

2. 玩家抓牌

3. 对玩家手上牌进行排序

   Arrays.sort(cards,0,number,new Comparator<String>() {
      @Override
      public int compare(String o1, String o2) {
        if(o1.charAt(1) > o2.charAt(1)){
          return 1;
        }else{
          return -1;
        }
      }
   });

   ​

4. 抢地主：

   1. 有王
   2. 2个二
   3. 至少一个炸弹

   public static int WANG = 1<<0; // 001
   public static int ER = 1<<1;  //010
   public static int ZHA = 1<<2; //100;
   public int isCallDizhu(){
       int cardNumbers[] = new int[17];
       for (int i = 0; i < cardNumbers.length; i++) {
           String card = cards[i];
           char num = card.charAt(1);
           switch (num) {
           case '王':
               cardNumbers[0]++;
               break;
           case '1':
               cardNumbers[10]++;
               break;
           case 'J':
               cardNumbers[11]++;
               break;  
           case 'Q':
               cardNumbers[12]++;
               break;  
           case 'K':
               cardNumbers[13]++;
               break;  
           case 'A':
               cardNumbers[1]++;
               break;  
           default: //2 - 9
               cardNumbers[num - '0']++;
               break;
           }
       }
   
       int result = 0;
       if(cardNumbers[0] > 0){  //判断是否有王
           result |= WANG;  // 000 | 001 =  001; 
       }
       if(cardNumbers[2] > 2){  //至少有两个二
           result |= ER;    // 001 | 010 = 011;
       }
       for (int i = 0; i < cardNumbers.length; i++) {
           if(cardNumbers[i] == 4){
               result |= ZHA;
           }
       }
       if(cardNumbers[0] == 2){  //判断双王
           result |= ZHA;
       }       
       return result;
   }

   ​