泛型的世界

什么是泛型

泛型的本质是指类型参数化
允许在定义类、接口、方法时使用类型形参，当使用时指定具体类型
所有使用该泛型参数的地方都被统一化，保证类型一致。如果未指定具体类型，默认是Object类型。集合体系中的所有类都增加了泛型，泛型也主要用在集合。

泛型的基础

泛型类

/**
 * 泛型类
 *
 */
public class ClassGenericity {
    public static void main(String[] args) {
        //创建对象并指定元素类型
        ObjectTool<String> tool = new ObjectTool<>();
        tool.setObj("ironMan");
        System.out.println(tool.getObj());

        //创建对象并指定元素类型
        ObjectTool<Integer> objectTool = new ObjectTool<>();
        // 如果我在这个对象里传入的是String类型的,它在编译时期就通过不了了.
        objectTool.setObj(10);
        System.out.println(objectTool.getObj());
    }

    static class ObjectTool<T> {
        private T obj;
        public T getObj() {
            return obj;
        }
        public void setObj(T obj) {
            this.obj = obj;
        }
    }
}

泛型方法

入参的时候才确定泛型是什么

/**
 * 泛型方法
 *
 */
public class MethodGenericity<T> {
    public static void main(String[] args) {
        //创建对象
        ObjectTool tool = new ObjectTool();
        //调用方法,传入的参数是什么类型,返回值就是什么类型
        tool.show("hello");
        tool.show(12);
        tool.show(12.5);
    }

    static class ObjectTool {
        //定义泛型方法,格式如下，无特殊意义，记住即可
        public <T> void show(T t) {
            System.out.println(t);
        }
    }
}

泛型类派生出的子类

/**
 * 泛型类派生出的子类
 */
public class SubclassGenericity {
    public static void main(String[] args) {
        // 测试第一种情况
        Inter<String> i = new InterImpl1();
        i.show("hello");

        // 编译错误
//        Inter<Integer> ii = new InterImpl1();
//        ii.show(1);

        // 第二种情况测试
        Inter<String> iii = new InterImpl2();
        iii.show("100");
    }
}

/**
 * 把泛型定义在接口上
 */
interface Inter<T> {
    void show(T t);
}

/**
 * 子类明确泛型类的类型参数变量
 */
class InterImpl1 implements Inter<String> {
    @Override
    public void show(String s) {
        System.out.println(s);
    }
}

/**
 * 子类不明确泛型类的类型参数变量，实现类也要定义出T的类型
 */
class InterImpl2<T> implements Inter<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

类型通配符

/**
 * 类型通配符
 */
public class TypeWildcard {

    private final static List<Integer> LIST_INTEGER = Arrays.asList(1, 2, 3, 4);

    private final static List<Object> LIST_OBJECT = Arrays.asList(1, 2, 3, 4);

    private final static List<String> LIST_STRING = Arrays.asList("a", "b", "c", "d");

    public static void main(String[] args) {
        TypeWildcard typeWildcard = new TypeWildcard();
        typeWildcard.test1(LIST_INTEGER);

        // typeWildcard.test2(LIST_STRING);
        typeWildcard.test2(LIST_OBJECT);

        typeWildcard.test3(LIST_INTEGER);

        typeWildcard.test4(LIST_INTEGER);

        /**上限通配符*/
        typeWildcard.test5(LIST_INTEGER);
        // typeWildcard.test5(LIST_STRING);

        /**下限通配符*/
    }

    public void test1(List list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

	// 注意：泛型中的Object跟我们平时的不一样，没有说有什么继承关系就可以的说法，只能传List<Object>
    public void test2(List<Object> list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

	// ？：通配符，可以匹配任意类型。只运行与类型没有关系的方法，不能调用与类型有关系的方法
    public void test3(List<?> list) {
        for (int i = 0; i < list.size(); i++) {
            // list.add(list.get(0)); // 编译错误
            System.out.println(list.get(i));
        }
    }

    public <T> void test4(List<T> list) {
        for (int i = 0; i < list.size(); i++) {
            // list.add(list.get(0)); // 编译阶段ok，但是运行时抛异常，Exception in thread "main" java.lang.UnsupportedOperationException
            System.out.println(list.get(i));
        }
    }

    public void test5(List<? extends Number> list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

泛型的上限与下限

泛型的上限：
格式：类型名称 <? extends 类> 对象名称
意义：只能接收该类型及其子类
泛型的上限
格式：类型名称 <? super 类> 对象名称
意义：只能接收该类型及其父类型

/**
 * PECS(Producer Extends Consumer Super)
 *
 * https://www.cnblogs.com/huoqm/p/13931363.html
 */
public class Pecs {

    /**
     * 【读取】
     * 如果要从集合中读取类型T的数据，并且不能写入，可以使用 ? extends 通配符；(Producer Extends)
     */
    public void testPECSextends() {
        List<Dog> dogs = Lists.newArrayList();
        dogs.add(new Dog());
        List<? extends Animal> animals = dogs;

        /**
         * animals是一个Animal的子类的List,由于Dog是Animal的子类，因此将dogs赋给animals是合法的，但是编译器会阻止将new Cat()加入animals。
         * 因为编译器只知道animals是Animal的某个子类的List，但并不知道究竟是哪个子类，为了类型安全，只好阻止向其中加入任何子类。那么可不可以加入
         * new Animal()呢？很遗憾，也不可以。事实上，不能够往一个使用了? extends的数据结构里写入任何的值。
         */
        // animals.add(new Cat()); // 编译失败
        // animals.add(new Animal()); // 编译失败
        // animals.add(new Dog()); // 编译失败

        /**
         * 由于编译器知道它总是Animal的子类型，因此我们总可以从中读取出Animal对象：
         */
        Animal animal = animals.get(0);
        // Dog dog = animals.get(0); // 编译失败
    }

    /**
     * 【写入】
     * 如果要从集合中写入类型T的数据，并且不需要读取，可以使用 ? super 通配符；(Consumer Super)
     * <p>
     * 如果既要存又要取，那么就不要使用任何通配符。
     */
    public void testPECSsuper() {
        List<Animal> animals = Lists.newArrayList();
        List<? super Dog> dogs = animals;
        /**
         * 这里的animals是一个Animal的超类（父类,superclass）的List。同样地，出于对类型安全的考虑，我们可以加入Dog对象或者其任何子类（如WhiteDog）对象，
         * 但由于编译器并不知道List的内容究竟是Dog的哪个超类，因此不允许加入特定的任何超类型。
         */
        dogs.add(new Dog());
        dogs.add(new WhiteDog());
        // dogs.add(new Animal()); // 编译失败
        // dogs.add(new Cat()); // 编译失败
        // dogs.add(new Object()); // 编译失败

        /**
         * 而当我们读取的时候，编译器在不知道是什么类型的情况下只能返回Object对象，因为Object是任何Java类的最终祖先类。
         */
        Object obj = dogs.get(0);
        // Dog dog = dogs.get(0); // 编译失败
        // Animal animal = dogs.get(0); // 编译失败
    }
}

类型擦除与桥接方法

泛型是提供给javac编译器使用的，它用于限定集合的输入类型， 让编译器在源代码级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后，生成的class文件中将不再带有泛型信息，以此使程序运行效率不受到影响，这个过程称之为 “擦除”。

由于类型被擦除了，为了维持多态性，所以编译器就自动生成了桥接方法。

MyNode表明setData里只能入参Integer类型。这个就是泛型的行为，但是，如果泛型被擦除了，那只能通过桥接方法，指定入参必须是Integer data，才能将原有setData(Object data)这个丢失了泛型行为的情况补偿回来

另外这个方法就是jvm为了弥补泛型丢失，而自己生成的方法，作为桥梁，连接了jdk5之前（没有泛型只能用Object）和jdk5之后又了泛型。所以才叫桥接方法。

因为泛型，只是咱们在编码阶段可以使用的编写方式，当编译到jvm的时候，就丢失了所谓的这种泛型标识了，那么就又桥接方法的出现，语法上既满足了java的原始语法，又不会丢失泛型的类型限制行为。

/**
 * 桥接方法
 * 1> 类型擦除 javac ——> class 泛型被擦除了！
 * 2> 泛型虽然被擦除了，但是，你一定要给我保留泛型的行为！
 * @param <T>
 */
public class Node(注：<T>原本此处有该泛型) {
    public Object(注：Object原本应该为T) data;
    public void setData(Object(注：Object原本应该为T) data) {
        this.data = data;
    }
}

/**
 * 桥接方法
 */
class MyNode extends Node(注：<Integer>原本此处有该泛型) {

	// 桥接方法
    public void setData(Integer data) {
        super.setData(data);
    }

    @Override
    public void setData(Object data) {
        setData((Integer) data);
    }
}