泛型是什么？

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

在集合中存储对象并在使用前进行类型转换是多么的不方便。泛型防止了那种情况的发生。它提供了编译期的类型安全，确保你只能把正确类型的对象放入 集合中，避免了在运行时出现ClassCastException。

优点

泛型的引入可以解决之前的集合类框架在使用过程中通常会出现的运行时刻类型错误，因为编译器可以在编译时刻就发现很多明显的错误。

类型擦除

泛型实在编译器层次来实现的

在生成的java字节代码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会被编译器在编译的时候去掉，这个就叫类型擦除。

如在代码中定义的List（Object）和List（String）等类型，在编译之后都会变成List。JVM看到的只是List，而由泛型附加的类型信息对JVM来说是不可见的，java编译器会在编译是尽可能发现出错的地方，但是仍然无法避免在运行时刻出现类型转换异常的情况。

泛型的奇怪特性都与类型擦除有关

1. 泛型类并没有自己独有的Class对象，比如并不存在List(String).class,z只有List.class
2. 静态变量是被泛型类的所有实例被共享的。对于声明为MyClass（T）的类，访问其中的静态变量的方法仍然是 MyClass.myStaticVar。不管是通过new MyClass（String）还是new MyClass（Integer）创建的对象，都是共享一个静态变量。
3. 泛型的类型参数不能用在java异常处理的catch语句中。因为异常处理是由JVM在运行时刻来进行的。由于类型信息被擦除，JVM是无法区分两个异常类型MyException（String）和MyException（Integer）的。对于JVM来说，它们都是 MyException类型的。也就无法执行与异常对应的catch语句。

类型擦除过程

找到用来替换类型参数的具体类。这个具体类一般是Object。如果指定了类型参数的上界的话，则使用上界。把代码中的类型参数都替换成具体类。同时去掉同时出现的类型声明，即去掉<>的内容。比如Tget(）方法声明就变成了Object get()；List（String）就变成了List。接下来就可能需要生辰改一些桥接方法。就是由于擦除了类型之后的类可能缺少默写某些必须的方法。这样做的目的，是确保能和Java 5之前的版本开发二进制类库进行兼容。你无法在运行时访问到类型参数，因为编译器已经把泛型类型转换成了原始类型。

实例分析

public void insert(List（Object) list) {    
    for (Object obj : list) {        
        System.out.println(obj);    
    }    
    list.add(1); //这个操作在当前方法的上下文是合法的。 
}
public void test() {    
    List（String） strs = new ArrayList（String）();    
    inspect(strs); //编译错误 
}

泛型类

public class Som<T> {
    private T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

Som就是一个泛型类，value的类型是T，而T是参数化的。如果有多个类型参数，使用分号隔开,如<U,V>。在编译期，是无法知道U和V具体是什么类型，只有在运行时才会真正根据类型来构造和分配内存。

public class Main {
    public static void main(String[] args) {
        Son<String, String> c1 = new Son<String, String>("name", "findingsea");
        Son<String, Integer> c2 = new Son<String, Integer>("age", 24);
        Son<Double, Double> c3 = new Son<Double, Double>(1.1, 2.2);
        System.out.println(c1.getKey() + " : " + c1.getValue());
        System.out.println(c2.getKey() + " : " + c2.getValue());
        System.out.println(c3.getKey() + " : " + c3.getValue());
    }
}输出：

name : findingsea
age : 24
1.1 : 2.2

可以看一下现在Som类对于不同类型的支持情况：
使用泛型类：

Som<String> som = new Som<>();
som.setValue("Hi");
//som.setValue(123);编译不通过
String str = som.getValue();

在使用中指定具体的类型实参。

泛型接口

public interface Generator<T> {
    public T next();
}
然后定义一个生成器类来实现这个接口：

public class FruitGenerator implements Generator<String> {

    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}
调用：

public class Main {

    public static void main(String[] args) {
        FruitGenerator generator = new FruitGenerator();
        System.out.println(generator.next());
        System.out.println(generator.next());
        System.out.println(generator.next());
        System.out.println(generator.next());
    }
}
输出：

Apple
Banana
Pear
Pear

泛型方法

在java中,泛型类的定义非常简单，但是泛型方法就比较复杂了。无论何时，只要你能做到，你就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛化，那么应该有限采用泛型方法。

泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。

如果你定义了一个泛型（类、接口），那么Java规定，你不能在所有的静态方法、静态初块等所有静态内容中使用泛型的类型参数。例如：

public class A<T> {
    public static void func(T t) {
    //报错，编译不通过
    }
}

泛型的通配符

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

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

public static void printList(List<?> list) {
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
    //一下操作不可以
    list.add(1);
    list.add("123");
}

public static void printList(List<? super String> list) {
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
    list.add("123");
    list.add("456");
}

Som<String> [] soms = new Som<String>[8];

Som<Integer>[] soms = new Som<Integer>[3];
Object[] objs = soms;
objs[0] = new Som<String>();