14 - 泛型

不精不诚，不能动人。

脚踏实地，自然而然。

1.泛型的理解与好处

编写程序，在ArrayList中，添加3个Dog对象

public static void main(String[] args) {
    // 使用传统的方法来解决
    ArrayList arrayList = new ArrayList();
    arrayList.add(new Dog("旺财", 10));
    arrayList.add(new Dog("发财", 1));
    arrayList.add(new Dog("小黄", 5));

    // 假如我们的程序员，不小心，添加了一只猫
    arrayList.add(new Cat("招财猫", 8));

    // 遍历
    for (Object o : arrayList) {
        // 向下转型 Object ->Dog
        Dog dog = (Dog) o;
        System.out.println(dog.getName() + "-" + dog.getAge());
    }
}


class Dog { // Dog 类
    private String name;
    private int age;

    //......
}

class Cat { // Cat 类
    private String name;
    private int age;

    //......
}

问题

• 不能对加入到集合中的数据类型进行约束，在下转型的时候会报错。
• 遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响。

使用泛型来解决，指定集合中的类型

public static void main(String[] args) {
    // 1. 当我们 ArrayList<Dog> 表示存放到 ArrayList 集合中的元素是 Dog 类型
    // 2. 如果编译器发现添加的类型，不满足要求，就会报错
    // 3. 在遍历的时候，可以直接取出 Dog 类型而不是 Object
    ArrayList<Dog> arrayList = new ArrayList<Dog>();
    arrayList.add(new Dog("旺财", 10));
    arrayList.add(new Dog("发财", 1));
    arrayList.add(new Dog("小黄", 5));

    //假如我们的程序员，不小心，添加了一只猫
    //arrayList.add(new Cat("招财猫", 8));

    System.out.println("===使用泛型====");
    for (Dog dog : arrayList) {
        System.out.println(dog.getName() + "-" + dog.getAge());
    }
}

好处

• 编译时，检查类型元素的类型，提高了安全性。
• 减少了类型转换的次数，提高效率。

2.泛型介绍

泛型的声明

interface <T>

class <K, V>

• 其中的 T K V 不代表值，代表一种类型
• 任意的字母都行，常用的是T，是Type的缩写 

泛型的实例化

List<String> list = new ArrayList<String>();

• 在类名后面指定类型参数的值（类型）

代码示例

public static void main(String[] args) {
    // 使用泛型方式给 HashSet 放入 3 个学生对象
    HashSet<Student> students = new HashSet<Student>();
    students.add(new Student("路明非", 18));
    students.add(new Student("凯撒", 19));
    students.add(new Student("楚子航", 19));

    // 遍历
    for (Student student : students) {
        System.out.println(student);
    }
}

class Student {
    private String name;
    private int age;

    //......
}

使用注意事项

1. interface <T> 其中的T只能是引用类型

• List<Integer> list = new ArrayList<Integer>();  //正确
• List<int> list = new ArrayList<int>();  //错误

2.  在给泛型指定具体类型后，可以传入该类型或者其子类类型

3.  List list = new ArrayList(); // 这样写默认泛型是 <E> 就是Object

3.自定义泛型

3.1 自定义泛型类

语法

class 类名 <T, R...> { // 可以有多个泛型
    // 成员
}


class Tiger<T, R, M> {
    String name;
    T t;
    R r;
    M m;
}

代码示例

public static void main(String[] args) {
    Tiger<Double, String, Integer> g = new Tiger<>("辛巴");
    g.setT(10.9); //OK
    //g.setT("yy"); //错误，类型不对
    System.out.println(g);
    Tiger g2 = new Tiger("辛巴"); // T=Object R=Object M=Object
    g2.setT("yy"); //OK ,因为 T=Object "yy"=String 是 Object 子类
    System.out.println("g2=" + g2);
}

class Tiger<T, R, M> {
    String name;
    R r; 
    M m;
    T t;
    // 因为数组在 new 不能确定 T 的类型，就无法在内存开空间
    T[] ts;

    public Tiger(String name) {
        this.name = name;
    }

    public Tiger(R r, M m, T t) {
        this.r = r;
        this.m = m;
        this.t = t;
    }
    public Tiger(String name, R r, M m, T t) {
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }


    // 方法使用泛型
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public R getR() {
        return r;
    }
    public void setR(R r) {
        this.r = r;
    }
    public M getM() {
        return m;
    }
    public void setM(M m) {
        this.m = m;
    }
    public T getT() {
        return t;
    }
    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "Tiger{" +
        "name='" + name + '\'' +
        ", r=" + r +
        ", m=" + m +
        ", t=" + t +
        ", ts=" + Arrays.toString(ts) +
    '}';
}

说明

• Tiger 后面泛型，所以我们把 Tiger 就称为自定义泛型类
• T, R, M 泛型的标识符, 一般是单个大写字母
• 泛型标识符可以有多个
• 普通成员可以使用泛型 (属性、方法)
• 使用泛型的数组，不能初始化
• 静态方法中不能使用类的泛型，因为静态是和类相关的，在类加载时，对象还没有创建，所以，如果静态方法和静态属性使用了泛型，JVM 就无法完成初始化

3.2 自定义泛型接口 

语法

interface 接口名 <T, R...> {

}

代码示例

interface IUsb<U, R> {
    int n = 10;
    //U name; 不能这样使用
    //普通方法中，可以使用接口泛型
    R get(U u);
    void hi(R r);
    void run(R r1, R r2, U u1, U u2);

    // 在 jdk8 中，可以在接口中，使用默认方法, 也是可以使用泛型
    default R method(U u) {
        return null;
    }
}

// 在继承接口 指定泛型接口的类型
interface IA extends IUsb<String, Double> {
}

// 实现 IA 接口时，因为 IA 在继承 IUsu 接口时，指定了 U 为 String R 为 Double
class AA implements IA {
    @Override
    public Double get(String s) {
        return null;
    }
    @Override
    public void hi(Double aDouble) {
    }
    @Override
    public void run(Double r1, Double r2, String u1, String u2) {
    }
}


class BB implements IUsb<Integer, Float> {
    @Override
    public Float get(Integer integer) {
        return null;
    }
    @Override
    public void hi(Float aFloat) {
    }
    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {
    }
}

// 没有指定类型，默认为 Object
class CC implements IUsb { //等价 class CC implements IUsb<Object,Object> {
    @Override
    public Object get(Object o) {
        return null;
    }
    @Override
        public void hi(Object o) {
    }
    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {
    }
}

说明

• 接口中，静态成员也不能使用泛型
• 泛型接口的类型，在继承接口或者实现接口时确定
• 没有指定类型，默认为Object

3.3 自定义泛型方法

语法

修饰符 <T, R> 返回类型 方法名(参数列表) {

}

代码示例

public static void main(String[] args) {
    Car car = new Car();
    car.fly("宝马", 100); // 当调用方法时，传入参数，编译器，就会确定类型
    System.out.println("=======");
    car.fly(300, 100.1); // 当调用方法时，传入参数，编译器，就会确定类型

    // 测试
    //T->String, R-> ArrayList
    Fish<String, ArrayList> fish = new Fish<>();
    fish.hello(new ArrayList(), 11.3f);
}

// 泛型方法，可以定义在普通类中, 也可以定义在泛型类中
class Car {//普通类
    public void run() { //普通方法
    }

    //说明 泛型方法
    //1. <T,R> 就是泛型
    //2. 是提供给 fly 使用的
    public <T, R> void fly(T t, R r) {//泛型方法
        System.out.println(t.getClass());//String
        System.out.println(r.getClass());//Integer
    }
}

class Fish<T, R> {//泛型类
    public void run() {//普通方法
    }
    public<U,M> void eat(U u, M m) {//泛型方法
    }

    //说明
    //1. 下面 hi 方法不是泛型方法
    //2. 是 hi 方法使用了类声明的 泛型
    public void hi(T t) {
    }
    //泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
    public<K> void hello(R r, K k) {
        System.out.println(r.getClass());//ArrayList
        System.out.println(k.getClass());//Float
    }
}

说明

• 泛型方法，可以定义在普通类中，也可以定义在泛型类中
• 当泛型方法被调用时，类型会确定

4.泛型的继承和通配符

介绍

• 泛型不具备继承性 List<Object> list = new ArrayList<String>(); // 错误
• <?> ：支持任意泛型类型
• <? extends A>：支持A类以及A 类的子类，规定了泛型的上限
• <? super A>：支持A类以及A 类的父类，不限于直接父类，规定了泛型的下限

代码示例

public static void main(String[] args) {
    Object o = new String("xx");
    // 泛型没有继承性
    //List<Object> list = new ArrayList<String>();

    // 举例说明下面三个方法的使用
    List<Object> list1 = new ArrayList<>();
    List<String> list2 = new ArrayList<>();
    List<AA> list3 = new ArrayList<>();
    List<BB> list4 = new ArrayList<>();
    List<CC> list5 = new ArrayList<>();

    // 如果是 List<?> c ，可以接受任意的泛型类型
    printCollection1(list1);
    printCollection1(list2);
    printCollection1(list3);
    printCollection1(list4);
    printCollection1(list5);

    // List<? extends AA> c： 表示 上限，可以接受 AA 或者 AA 子类
    // printCollection2(list1);//×
    // printCollection2(list2);//×
    printCollection2(list3);//√
    printCollection2(list4);//√
    printCollection2(list5);//√

    // List<? super AA> c: 支持 AA 类以及 AA 类的父类，不限于直接父类
    printCollection3(list1);//√
    //printCollection3(list2);//×
    printCollection3(list3);//√
    //printCollection3(list4);//×
    //printCollection3(list5);//×
}

class AA {
}
class BB extends AA {
}
class CC extends BB {
}