泛型的定义

Java 泛型（generics）是 JDK1. 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许开发者在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

我们为什么需要泛型？

先看一个需求：计算两个int值之和，两个float值之和,两个double值之和

public class NoGeneric {
    public int addInt(int x, int y) {
        return x + y;
    }
    public float addFloat(float x, float y) {
         return x + y;
    }
    public double addDouble(double x, double y) {
        return x + y;
    }
   
}

我们会发现其实计算两个数之和的逻辑是一样的，只是传入的参数类型不一样而已，那么泛型就是可以用于多种数据类型执行相同的代码。这就是我们要用泛型的原因。

再看一个例子

public class NoGeneric {
    public static void main(String[] args) {
        //定义一个集合    
        List datas = new ArrayList();
        datas.add("Android");
        datas.add("NDK");
        datas.add(100);

        for (int i=0; i<datas.size();i++ ) {
            //当i=2时 这段代码会报类型转化异常。
            String name = (String) datas.get(i);
            System.out.println("name:"+name);
        }
    }
}

List 集合没有强调存放类型，即可为任意类型（Object），当我们遍历时，取出名字并为强转为String类型时，发现Interger转换时就会报类型转换异常了。

在 JDK1.5 之前，集合是没有泛型的，添加的数据都是 Object 类型，因此可以往里面添加任意类型的数据，而在取出数据时，是需要判断类型，然后进行强制转化的，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的，对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现ClassCastException异常，这是本身就是一个安全隐患。

如果我们用了泛型指定了集合的存放类型List<String>，那么集合只能存放指定的类型。如果存放其他类型编译期间直接提示类型错误，而不是到运行时才发现。同时我们在使用时就避免强制转换类型。这就是使用泛型的另一个好处。

泛型的好处

• 在编译的时候能够检查类型安全，并且所有的强制转换都是自动和隐式的。
• 可以用于多种数据类型执行相同的代码，提高的运行效率。

泛型的作用

• 泛化

  可以用A~Z任意一个字母代表任意类型。

• 类型安全

  在编译期就能发现类型错误，从而减少运行期可能发生ClassCast Exception异常。

• 消除强制类型转换

  消除源代码中的许多强制类型转换，这样可以使代码更加可读，并减少出错的机会。

• 向后兼容

  支持泛型的Java编译器（例如JDK1.5中的Javac）可以用来编译经过泛型扩充的Java程序（Generics Java程序），但是现有的没有使用泛型扩充的Java程序仍然可以用这些编译器来编译。

泛型在类，接口以及方法的使用

泛型在类，接口以及方法的使用，都在下面代码中体现了。泛型使用 <T> 表示。

public class GenericsType<T> {

    private T t;
    //这个不是泛型方法，虽然该方法使用了泛型，但是这个泛型是在GenericsType中定义的，
    public T get() {
        return t;
    }
    public void set(T t) {
        this.t = t;
    }
    //不指定类型
    public void noSpecifyType(){
        GenericsType obj = new GenericsType();
        obj.set("hello");
        //需要强制类型转换
        String str = (String) obj.get();
        System.out.println(str);
    }

    //指定类型
    public void specifyType(){
        GenericsType<String> obj = new GenericsType<>();
        obj.set("word");
        //obj.set(100);//编译时候检查类型安全，提示类型错误
        //不需要强制类型转换
        String str = obj.get();
        System.out.println(str);
        //可以在编译时候检查类型安全，可以用在类，方法，接口上。
    }

    //泛型接口
    public interface CallBackInterface<Data>{
        void getData(Data data);
    }

    /***
     * 泛型方法 是在调用方法的时候指明泛型的具体类型，泛型方法可以在任何地方和任何场景中使用，包括普通类和泛型类。
     * 上面的get()方法是普通方法，返回的类型由泛型类的泛型决定而已。
     */
    private <K> K getData(K k){
        return k;
    }

}

泛型中通配符

在定义泛型类，泛型方法，泛型接口的时候经常会碰见很多不同的通配符，比如 T，E，K，V 等等，这些通配符又都是什么意思呢？
常用的 T，E，K，V，？
本质上这些个都是通配符，没啥区别，只不过是编码时的一种约定俗成的东西，没有标准的。比如上述代码中的 T ，我们可以换成 A-Z 之间的任何一个 字母都可以或者使用多个字母组合作通配符也是可以的，并不会影响程序的正常运行，但是如果换成其他的字母代替 T ，在可读性上可能会弱一些。通常情况下，T，E，K，V，？是这样约定的：

• ？表示不确定的 java 类型
• T (type) 表示具体的一个java类型
• K V (key value) 分别代表java键值中的Key Value，当然也可以表示java类型
• E (element) 代表Element，当然也可以表示java类型

？无界通配符

先看一个计算动物有几条脚的例子：

public class TestGenerics {

    public static void main(String args[]){
        List<Dog> dogs = new ArrayList<>();
        List<Cat> cats = new ArrayList<>();
        TestGenerics test = new TestGenerics();
        test.countLegs1(dogs);//报错提示
        test.countLegs2(dogs);
        test.countLegs2(cats);
    }
    
    private int countLegs1(List<Animals> animals){
        int legs = 0;
        for (Animals animal : animals) {
            legs += animal.getLegs();
        }
        return legs;
    }
    private int countLegs2(List<? extends Animals> animals){
        int legs = 0;
        for (Animals animal : animals) {
            legs += animal.getLegs();
        }
        return legs;
    }
    private class Animals{
        public int getLegs(){
            return 0;
        }
    }
    private class Dog extends Animals{
    }
    private class Cat extends Animals{
    }
}

调用countLegs1(dogs)提示错误了

为什么要使用通配符而不是简单的泛型呢？通配符其实在声明局部变量时是没有什么意义的，但是当你为一个方法声明一个参数时，它是非常重要的。对于不确定或者不关心实际要操作的类型，可以使用无限制通配符（尖括号里一个问号，即 <?>），表示可以持有任何类型。像 countLegs2 方法中，限定了上届，但是不关心具体类型是什么，所以对于传入的 Animal 的所有子类都可以支持，并且不会报错。而 countLegs1 就不行。

上界通配符 < ? extends X>

上界：用 extends 关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。

在类型参数中使用 extends 表示这个泛型中的参数必须是 X 或者 E 的子类，这样有两个好处：

• 如果传入的类型不是 X 或者 X 的子类，编译不成功。
• 泛型中可以使用 X 的方法，要不然还得强转成X才能使用。

类型参数列表中如果有多个类型参数上限，用逗号分开。

public class A implements Comparable {
        @Override
        public boolean equals(Object obj) {
            return false;
        }
        @Override
        public int compareTo(Object o) {
            return 0;
        }
}
public class B implements Comparable {
        @Override
        public boolean equals(Object obj) {
            return false;
        }
        @Override
        public int compareTo(Object o) {
            return 0;
        }
}

private <K extends A, E extends B> E testCompare(K k1, E e1){
    E result = e1;
    e1.compareTo(k1);
    //.....
    return result;
}

public class GenericsType<T> {

    private T t;
    public T get() {
        return t;
    }
    public void set(T t) {
        this.t = t;
    }
    public GenericsType(T t) {
        this.t = t;
    }
    public GenericsType() {
    }

    public static void main(String []args){
        GenericsType<? extends Dog> obj = null;
        GenericsType<Animals> animal = new GenericsType<>();
        GenericsType<Dog> dog = new GenericsType<>();

        //Dog 是 Animals的子类
        obj = animal;//编译错误
        //<? extends Dog>接受Dog及其Dog子类
        obj = dog;//通过编译

        //set()知道传入的类型是Dog类型，但是具体是什么子类型，还是不清楚的。因此这种方式是不安全的。
        obj.set(new Dog());//编译错误   set方法的参数是一个伪泛型   编译时会被擦除
        obj.set(new BigDog());//编译错误

        //BigDog 是 Dog的子类
        obj = new GenericsType<>(new BigDog());
        Dog dog = obj.get();//通过编译

    }
}

编译不通过的原因：

• obj = animal;//编译错误，原因：Dog 是Animals的子类
• obj.set(new Dog());//编译错误
  obj.set(new BigDog());//编译错误
  原因：虽然知道set()传入的参数类型是Dog类或Dog的子类，但是具体是什么子类型，还是不清楚的，可把set方法参数理解一个伪泛型，在编译时会被擦除。因此这种方式是不安全的。

Dog dog = obj.get();//通过编译 为什么返回的是Dog类型？ obj.get()接受的数据一定会是 Dog或者 Dog的子类，但是不管是哪个，都是可以用 Dog这个父类去接受，可理解为Dog是一个占位符（? extends Dog == Dog）这个可以用多态去解释。注意：如果是Dog的子类接收，需要强转

上界：取(get)出来的类型不会丢失，存(set)放会丢失类型。(？代表容器里的元素类型为X基类类型，X是所有元素的基类，存（即set）进去就无法确定是那个具体的类型了，取(get)出来就没有问题，因为X是表示所有基类)

下界通配符 < ? super E>

用 super 进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至 Object。

public class GenericType<T> {
    private T t;
    public T getData() {
        return t;
    }
    public void setData(T t) {
        this.t = t;
    }
}

//下界通配符 下界的父类为Dog 是Dog的超类都可以打印
    private static void println(GenericType<? super Dog> p){
        System.out.println(p.getData());
    }

    private static void  useSuper(){
        GenericType<Animal> animalGeneric = new GenericType<>();
        GenericType<Dog> dogGeneric = new GenericType<>();
        GenericType<BigDog> bigDogGeneric = new GenericType<>();
        GenericType<Cat> catGeneric = new GenericType<>();

        println(animalGeneric);
        println(dogGeneric);
//        println(bigDogGeneric);//BigDog是Dog的子类，不是Dog的超类，编译不通过
//        println(catGeneric);//Cat虽然和Dog是一个等级 Cat不是Dog的超类，编译不通过

       GenericType<? super Dog> g = new GenericType<>();
        g.setData(new Dog());
        g.setData(new BigDog());//BigDog是Dog的子类,不能安全转型为Dog
        g.setData(new Animal());//Animal不能安全转型为Dog

    }

    public class Animal {
    }
    public class Dog extends Animal {
    }
    public class BigDog extends Animal {
    }
    public class Cat extends Animal {
    }

上述的BigDog类和Cat类都不是Dog的超类，没有编译报错，反之是Dog本身或Dog的超类都可以打印。GenericType<? super Dog> g = new GenericType<>();setData(T t)方法，输入的t就是Dog类本身，如果传入BigDog类或Animal类时，编译报错，因为不能安全转型为Dog。

下界： 取（get）出来的类型会丢失，存（set）放不会丢失类型。（？代表容器里的元素类型为E基类类型，存（即set）进去的都是E的超类，取（get）出来就不知道是那个具体的类型，这样就没法统一基类类型了，全部都为Object。

泛型类型擦除 （面试常问）

前面上界内容提到了Java的泛型是伪泛型。为什么说Java的泛型是伪泛型呢？因为，在编译期间，所有的泛型信息都会被擦除掉。正确理解泛型概念的首要前提是理解类型擦除（type erasure）。
Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会在编译器在编译的时候去掉。这个过程就称为类型擦除。

如在代码中定义的List<object>和List<String>等类型，在编译后都会编程List。JVM看到的只是List，而由泛型附加的类型信息对JVM来说是不可见的。Java编译器会在编译时尽可能的发现可能出错的地方，但是仍然无法避免在运行时刻出现类型转换异常的情况。类型擦除也是Java的泛型实现方法与C++模版机制实现方式之间的重要区别。

下面通过两个例子，看看泛型类型是怎么擦除的。

public class Test {
    public static void main(String[] args) {
        ArrayList<String> arrayList1=new ArrayList<String>();
        arrayList1.add("abcde");
        ArrayList<Integer> arrayList2=new ArrayList<Integer>();
        arrayList2.add(1);
        System.out.println(arrayList1.getClass()==arrayList2.getClass());
    }
}

上述例子中，定义了两个ArrayList数组，不过一个是ArrayList<String>泛型类型，只能存储字符串。一个是ArrayList<Integer>泛型类型，只能存储整形。最后，我们通过arrayList1对象和arrayList2对象的getClass方法获取它们的类的信息，最后发现结果为true。说明泛型类型String和Integer都被擦除掉了，只剩下了原始类型。

public class Test{
    public static void main(String[] args) throws IllegalArgumentException, SecurityException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        ArrayList<Integer> arrayList=new ArrayList<Integer>();
        arrayList.add(1);//调用add方法只能存储整形，因为泛型类型的实例为Integer
        //通过反射向arrayList存一个String值
        arrayList.getClass().getMethod("add", Object.class).invoke(arrayList, "aaaaaaa");
        for (int i=0;i<arrayList.size();i++) {
            System.out.println(arrayList.get(i));
        }
      }
}

上述代码中定义了一个ArrayList泛型类型实例化为Integer的对象，如果直接调用add方法，那么只能存储整形的数据。不过当我们利用反射调用add方法的时候，却可以存储字符串。这说明了Integer泛型实例在编译之后被擦除了，只保留了原始类型。

总结

• 重点理解上界和下界的特点和使用
• 重点理解泛型类型擦除原理