泛型（泛型类、泛型接口、泛型方法、通配）

泛型类

注意细节
1)普通成员可以使用泛型(属性、方法)2)使用泛型的数组，不能初始化
2)使用泛型的数组，不能初始化
3)静态方法中不能使用类的泛型
4)泛型类的类型，是在创建对象时确定的(因为创建对象时，需要指定确定类型)
5)如果在创建对象时，没有指定类型，默认为Object

// 1、每个类可以有多个泛型
// 2、T、R、W是泛型的标识符，一般使用大写字母表示
// 3、每一个泛型可以代表一种数据类型
class Tree<T, R, W> {
    String name;
    T t;
    R r;
    W w;
//    T t = new T[8]; 不允许初始化
    public Tree(String name, T t, R r, W w) {
        this.t = t;
        this.r = r;
        this.w = w;
        this.name = name;
    }
    public void add(T t, R r, W w) {
        this.t = t;
        this.r = r;
        this.w = w;
    }

//    泛型不允许在静态变量上使用
//    因为在类加载的时候也就是在初始化阶段加载static代码块时这个类还没有创建，这个T的类型还没能确定
//    public static void run(T t) {
//    }
}

泛型接口

泛型接口顾名思义就是在接口上定义泛型。如下代码块所示

interface AA<R, T> {
    R getR(T t);

    void hi(R r);

    void run(T t);
}

在其它类中实现这个接口时需要注意可以显示的定义泛型的类型。显示定义这些类型时，里面的方法也需要改成对应的类型。当没有显示定义时就是默认的Object类型
显示定义泛型类型

public class CustomlnterfaceGeneric implements AA<String, Integer>{
    @Override
    public String getR(Integer integer) {
        return null;
    }

    @Override
    public void hi(String s) {

    }

    @Override
    public void run(Integer integer) {

    }
}

对泛型类型不处理

public class CustomlnterfaceGeneric implements AA{

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

    @Override
    public void hi(Object o) {

    }

    @Override
    public void run(Object o) {

    }
}

泛型方法

泛型方法是使用的比较多的一种泛型，主要是调用方法声明泛型，也可以调用类所声明的泛型。

class plane {
    public void run() {

    }

    // 1、<T, R>是泛型
    // 2、<T, R>是提供给fly使用的，必须是第一步先声明的才能使用
    // 3、泛型M可以是类定义的泛型。
    public <T, R> void fly(T t, R r, M m) {

    }
}

上述代码块中fly就是一个泛型方法，需要注意的是fly参数的泛型必须是在void前面声明才可以使用（也可以使用类定义的泛型）。在调用fly方法时也必须要对fly方法的泛型进行类型确定。

public class CustomMethodGeneric {
    public static void main(String[] args) {
        plane plane = new plane();
        plane.fly("test",110,999);
    }
}

通配

public class GenericExtends {

    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        List<BB> list2 = new ArrayList<>();
        List<CC> list3 = new ArrayList<>();
        List<DD> list4 = new ArrayList<>();

        printCollection(list1); //√
        printCollection(list2); //√
        printCollection(list3); //√
        printCollection(list4); //√

        printCollection1(list1); //×
        printCollection1(list2); //×
        printCollection1(list3); //√
        printCollection1(list4); //√

        printCollection2(list1); //√
        printCollection2(list2); //√
        printCollection2(list3); //√
        printCollection2(list4); //×
    }

    // 任何泛型都支持
    public static void printCollection(List<?> list) {

    }
    // 只能是CC或者CC的子类
    public static void printCollection1(List<? extends CC> list) {

    }
    // 只能是CC或者CC的父类
    public static void printCollection2(List<? super CC> list) {

    }
}
class BB {

}

class CC extends BB {

}

class DD extends CC {

}