泛型

1.泛型的由来

       Java泛型是JDK5中引入的新特性，提供了一种编译时安全检测机制，允许在定义类/接口/方法的时候使用类型参数，声明的类型参数在使用时用具体的类型来替换，允许程序员在编译时检测到非法类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

2.泛型的意义

       在没有泛型之前，是要做显式的强制类型转换。针对不同参数得写出几个对应的方法。使用泛型好处是让编译器保留参数类型信息，执行类型检查，执行类型转换操作，同时省掉了显式的强制类型转换，保证了这些类型转换的正确性，保证类型安全，并实现了更为通用的算法。在编译时就能发现插入类型的错误，也不需要手动转换类型。

3.泛型的种类

泛型类

       泛型类声明和非泛型类的声明类似，除了在类名后面添加类型参数声明部分。泛型类的类型参数声明包含一个或多个类型参数，参数之间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符，因为他们接受一个或者多个参数，这些类被称为参数化的类或者参数化的类型。

public class GenericTest{
    public static void main(String[] args) {
        Box name = new Box("corn");
        Box age = new Box(712);
        System.out.println("name class:" + name.getClass());
        System.out.println("age class:" + age.getClass());
        System.out.println(name.getClass() == age.getClass());
    }
 
    static class Box {
        private T data;
        public Box() {}
        public Box(T data) {
            this.data = data;
        }
        public T getData() {
            return data;
        }
    }
}

      在使用泛型类时候，虽然传入了不同的泛型实参，但没有真正意义上生成不同的类型，传入不同泛型实参的泛型类在内存中只有一个，即为原来的最初类型，在逻辑中可以理解为多个不同的泛型类型。究其原因是泛型只是作用于代码编译阶段，在编译过程中正确检测出了泛型信息，会将泛型的相关信息擦除，即成功编译后的class文件不包含任何泛型信息，泛型信息不会进入运行时阶段。

泛型接口

      在接口处使用泛型，使用比较方便

public class GenericTest{
    public static void main(String args[]) {
        generic i = null;
        i = new genericImpl<>("it");
        System.out.println("Length Of String : " + i.getVar().length());
    }
}
 
interface generic {
    T getVar();
}
 
class genericImpl implements generic {
    private T var;
 
    public genericImpl(T var) {
        this.setVar(var);
    }
 
    public void setVar(T var) {
        this.var = var;
    }
 
    public T getVar() {
        return this.var;
    }
}

泛型方法

      一个基本原则是无论何时，只要你能做到，你就应该尽量使用泛型方法。

public class GenericTest{
    public static void main(String args[]) {
        out("findingsea");
        out(123);
        out(11.11);
        out(true);
    }
 
    public static  void out(T t) {
        System.out.println(t);
    }
}

       可以看到方法的参数彻底泛化了，原来需要自己对类型进行判断和处理，现在交给编译器来做了。这样在定义方法的时候，大大增加了编程的灵活性。

4.类型擦除

      类型擦除指的是通过类型参数合并，编译器只为泛型类型生成一份字节码，将泛型类型实例关联到同一份字节码上。在生成的Java字节码中不包含泛型类型信息的，类型擦除的关键在于从泛型类型中清除类型参数的相关信息，并且在必要的时候添加类型检查和类型转换的方法。具体过程为：

      1.检查代码中的泛型类型

      2.将所有泛型参数用它们的原始类型替换

      3.编译代码

      需要注意的是：泛型的类型参数不能用在Java异常处理的catch语句中。因为异常处理是由JVM在运行时刻来进行的，但是类型信息已经被擦除了。泛型类并没有自己独有的Class类对象。静态变量是被泛型类的所有实例所共享的。

List list = new ArrayList();
Map map = new HashMap();
System.out.println(Arrays.toString(list.getClass().getTypeParameters()));
System.out.println(Arrays.toString(map.getClass().getTypeParameters()));
  
/* Output
[E]
[K, V]
*/

      这种代码的输出，我们期待 是得到泛型参数的类型，但是实际上我们只得到了一堆占位符。

public class Main {
    public T[] makeArray() {
        // error: Type parameter 'T' cannot be instantiated directly
        return new T[5];
    }
}

      这种出现错误是因为我们无法在泛型内部创建一个T类型的数组，因为T仅仅是个占位符，并没有真正的类型信息，实际上除了new表达式外，instanceof操作和转型是在泛型内部无法使用的，而这个原因是对编译器对类型信息进行了擦除。

public class Main {
 
    private T t;
 
    public void set(T t) {
        this.t = t;
    }
 
    public T get() {
        return t;
    }
 
    public static void main(String[] args) {
        Main m = new Main();
        m.set("findingsea");
        String s = m.get();
        System.out.println(s);
    }
}
 
/* Output
findingsea
*/

     虽然编译器无法知道T的类型信息，但是编译器可以保证的是：内部的一致性。

class GenericTest
    public List fillList(T t, int size) {
        List list = new ArrayList();
        for (int i = 0; i < size; i++) {
            list.add(t);
        }
        return list;
    }
 
 
    public static void main(String[] args) throws Exception{
 
        GenericTest m = new GenericTest();
        List list1 = m.fillList("findingsea", 5);
        System.out.println(list1.toString());
    }
}

     输出为[findingsea, findingsea, findingsea, findingsea, findingsea]，同样保证了一致性。

5.类型擦除带来的问题以及解决

public static  void main(String[] args) { 
        ArrayList arrayList=new ArrayList(); 
        arrayList.add("123"); 
        arrayList.add(123);//编译错误 
    }

      泛型变量Integer会被擦除为Object，为什么ArrayList不能存别的类型，在类型擦除的情况下，如何保证我们加入的是泛型变量指定的类型？因为Java编译器是先检查代码中泛型的类型，再进行类型擦除，然后进行编译。

      泛型中的引用传递问题：

ArrayList arrayList1=new ArrayList(); 
        arrayList1.add("1");//编译通过 
        arrayList1.add(1);//编译错误 
        String str1=arrayList1.get(0);//返回类型就是String 
ArrayList arrayList2=new ArrayList();
arrayList2.add("1");//编译通过
arrayList2.add(1);//编译通过
Object object=arrayList2.get(0);//返回类型就是Object

       类型检查是针对引用的，谁是引用，就对这个引用调用的方法进行类型检测，而无关它真正引用的对象。  

ArrayList