2022/08/01 学习笔记 （day21） 泛型和枚举

目录

        一.泛型

        1.什么是泛型？

        2.泛型的修饰：

        3.泛型方法：

        4.泛型类在继承关系时：

        5.类型擦除：

二.枚举： 

        1.什么是枚举？

        2.定义枚举类型： 

---

一.泛型

        1.什么是泛型？

泛型广泛的、普通的类型。

泛型能够帮助我们把【类型明确】的工作推迟到创建对象或者调方法的时候。

泛型是指“类型参数化”，使用泛型可以屏蔽程序在运行时的类型转换异常，减少强制类型转换的使用，并且可以让异常在编译期暴露出来

class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
  private 泛型标识 /*（成员变量类型）*/ var; 
  .....

  }
}

           2.泛型的修饰：

 1、泛型类
 2、泛型方法
 3、泛型接口
 
  泛型类把泛型定义在类上，用户在使用类的时候才能把类型给确定。
  具体的使用方法使用<>加上一个未知数。通常用T K V E等大写字母表示。
  实际上用啥都行，只要是个单词就可以。

 如果一个泛型类，在创建对象的时候没有指定泛型类型：
        1.默认还是Object
        2.在使用这个类的时候，去确定泛型类型
        3.现在这个超级数组就只能存String类型
        4.不规范

        3.泛型方法：

我们如果只关心某个方法，可以不定义泛型类，只定义泛型方法。

        泛型方法是不是一定要在泛型类里？不是
        泛型类里是不是一定要有泛型方法？不是
 

在定义泛型方法时，要首先定义泛型类型。
定义在方法中间，泛型的使用处之前

public class Ch03 {

    public <T> T show(T t) {
        // 拿着这个t在方法中做好多事情，再把t返回回去
        // 调用另一个方法
        System.out.println(t);
        return t;
    }

    public static void main(String[] args) {
        new Ch03().show("哈哈");
    }
}

使用泛型方法，最好要结合返回值，和Object一样。

         4.泛型类在继承关系时：

1.父类是一个泛型类，子类要不要是泛型类？
2.永远记住，泛型的声明只能在当前类名后或者方法中间，而且声明的泛型是自己的。
3.在子类继承父类时，子类泛型和父类泛型都写出来的情况下，父跟子
4.如果在继承时，没有写出任何泛型，当前子类就不是泛型类。

如果在一个泛型类中，尽量就不要再使用泛型方法。
泛型方法多数都是出现在非泛型类。

class Father<T> {

    T t;
}
// 在确定子类泛型的时刻，父类的泛型和子类一样
class Son<T> extends Father<T> {

}
//
class Son2 extends Father {

}
public class Ch04 {

    public static void main(String[] args) {
        Son<Employee> son = new Son<>();
        son.t = new Employee();
        Son2 son2 = new Son2();
        son2.t.notify();
    }
}

 
静态泛型方法：
1.静态方法如果是泛型方法，泛型的声明必须写。
2.因为静态结构是属于类的，不属于某个对象。

interface Inter<T> {

    T show(T t);

    static <T> T info(T t){

        return t;
    }

}
class Demo01<T> implements Inter<T> {

    @Override
    public Object show(Object o) {
        return null;
    }

    @Override
    public T show(T t) {
        return t;
    }
}
public class Ch05 {

    public static void main(String[] args) {
        Inter.info(1);
    }
}

       ?通配符
      可以接受任何类型。
      如果使用Object类型，别写泛型。
      泛型约束类的数据类型。

        5.类型擦除：

为了兼容性，使用原始类型（没有泛型）是可以的。
泛型刚刚出现的时候，还存在大量的不适用泛型的代码。
保证代码的兼容性，将参数化类型的实例传递给设计用于原始类型的方法必须是合法的。

为了保持兼容性，Java泛型中，其实有一种类似伪泛型，因为Java在编译期间，
所有的泛型都会被擦掉。

Java的泛型语法是在编译期这个维度上实现的。
正常来说在生成的字节码文件中，不包含泛型的类型信息的。

在JVM中看到的只是SuperArray，由泛型附加的类型信息对JVM是看不到的。

可以理解为，泛型的本质就是让程序员在编写代码时遵守的一个规则。

比如SuperArray：在确定了泛型之后，这个超级数组中就统一只放同一类型的数据。
              如果放入其他类型，编译不通过。

小经验：
        开发中，能够在业务上解决的问题，尽量不要在技术上解决。

1.泛型不能是基本数据类型。（原则上来说，数组可以作为泛型，语法角度，不可以）
     <>里面放的就应该是类名。数组是在编译后才会生成一个类（$xxxx）
2.方法重载：a.同一个类里  b.方法名相同  c.参数不同
     原理：类型擦除。
3.多态上。

 泛型的应用场景：
1.父类（接口），起到的是一个规范的作用，对里面的数据类型没有明确要求。
2.容器类。（超级数组，链表，队列，栈）

当类型无法确定时，使用泛型。

开发中，我们更多的是会使用到一些泛型类或泛型接口。

二.枚举： 

        1.什么是枚举？

        单例模式中，即一个类只有一个实例。而枚举其实就是多例，一个类有多个实例，但实例的个数不是无穷的，是有限个数的。我们称呼枚举类中实例为枚举项！枚举类的枚举项的个数不应该太多！

        2.定义枚举类型： 

public enum Direction{
    Spring,Summer,Autumn,Winter;
}
Direction d = Direction.FRONT;

关键字：enum

public class Sh02 {
    public static void main(String[] args) {
        System.out.println(sr.S.chang);

    }

    private int id;
    private String name;

    public Sh02(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
enum sr{
    S(1,"唱"),
    Q(2,"跳"),
    R(3,"篮球"),
    J(4,"鸡");

    int i;
    String chang;

    sr(int i, String chang) {
        this.chang = chang;
        this.i = i;
    }
}

课后练习：

/*
熊大[5,      10, 7, 8, 3, K, 8, 6, 10, 8, J, K, A, K, 10, J, 7]
熊二[A, 4, Q, 9, 2, 9, J, 6, 小王, 5, 6, 3, 8, Q, Q, 2, 3]
光头强[A, 3, 7, 5, 10, 大王, 4, 9, J, 7, 2, 5, Q, K, 4, 6, 9]
底牌[4, A, 2]Collections(工具类)里面shuffle
 */
import java.util.ArrayList;
import java.util.Collections;

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList userPoker = getUserPoker();
        System.out.println("熊大：" + userPoker.get(0).toString());
        System.out.println("熊二：" + userPoker.get(1).toString());
        System.out.println("光头强：" + userPoker.get(2).toString());
        System.out.println("底牌：" + userPoker.get(3).toString());
    }
    public static ArrayList<String> getPoker(){
        ArrayList<String> poker = new ArrayList<>();
        String[] arr1 = new String[]{"","","",""};
        String[] arr2 = new String[]{"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        poker.add("大王");//存大王
        poker.add("小王");//存小王
        for (int i = 0; i < 4 ; i++) {
            for (int j = 0; j < 13; j++) {
                poker.add(arr1[i] + arr2[j]);
            }
    }
        return poker;
    }
    public static ArrayList getUserPoker(){
        ArrayList<ArrayList<String>> userArr = new ArrayList<>();
        for (int i = 0; i < 4; i++) {
            userArr.add(new ArrayList<String>());
        }
        ArrayList<String> arrayList = getPoker();
        Collections.shuffle(arrayList);//打乱牌库
        for (int i = 0; i < 17; i++) {
            for (int j = 0; j < 3; j++) {
                userArr.get(j).add(arrayList.get(3 * i + j));
            }
        }//玩家的牌
        for (int i = 51; i < 54; i++) {
            userArr.get(3).add(arrayList.get(i));
        }//底牌
        return userArr;
    }
}