1、为什么使用泛型

泛型是指参数化类型的能力。可以定义带有泛型类型的类或类，随后编译器会使用具体的类型来代替它。
使用泛型会有如下好处：
1、类型安全。泛型的主要目的是为了提高Java程序的类型安全。
2、消除强制类型转换。消除代码中的强制类型转换，提高代码的可读性，减少出错的机会。
3、潜在的性能收益。为JVM优化提供可能性

2、泛型的原理

Java有Java编译器和Java虚拟机，编译器将Java源代码转换为.class文件，虚拟机加载并运行.class文件。对于泛型类，Java编译器会将泛型代码转换为普通的非泛型代码，将类型参数T擦除，替换为Object，插入必有的强制类型转换。这样做是为了实现兼容性的。知道这一点对于理解Java泛型的许多限制很有用。

3、泛型的使用

泛型类的定义

class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型{
  private 泛型标识 /*（成员变量类型）*/ var; 
  }
}

泛型接口的定义

//定义一个泛型接口
public interface Generator<T> {
    public T next();
}

泛型方法的定义

public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
  IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}

总结：泛型类和泛型接口的类型参数都是跟在接口名或类名之后，而泛型方法的类型参数在方法返回值之前。

4、泛型的局限

1、不能使用基本类型实例化类型参数
因为泛型在执行类型擦除后，变成了Object类型的域，而Object是不能存储如int这样的基本类型
2、不能创建参数类型的数组
3、不能实例化类型变量T
因为在编译的过程中就进行了类型擦除，在需要的实例化的时候找到合适的构造函数
4、泛型类的静态上下文中类型参数失效
参数类型是在实例化泛型类型的时候才会传入，而静态的上下文会脱离具体类而存在，所以类型参数会失效。

5、泛型中T ? extends super的理解

在这个问题上，可以分为两类来说明，首先是 T 和?表示类型，而extends和super表示上限。
在泛型定义的时候，使用T，T extends，或者T super等，如果需要多个不同类型的泛型，则可以加上E S等，其实使用 T E S没有太大的区别仅仅是字母的名字不相同而已。

        //在泛型的使用中，对于赋值的语句
        //应该从两个方面来理解，等号左边
        //定义了变量的类型，如list是一个能够存放Number子类的list。
        //等号右边就是要赋值的内容，只要符合就可以赋值成功
        List<? extends Number> list = null;
        List<Integer> list1 = new ArrayList<>();
        //对于使用通配符定义的泛型类型变量，
        //只能访问其中的值，不能通过该变量
        //来修改集合中的内容，但可以通过原
        //来的集合来修改集合的内容。
        list1.add(9);
        list = list1;
        System.out.println(list.get(0));
        list1.add(10);
        System.out.println(list.get(1));

在定义类或者方法时候

class TestAnimals <T extends Annimals>{
    T anni;
    public TestAnimals(T anni) {
        this.anni = anni;
    }
    public void test() {
        anni.say();
    }
}

//这种方法是有问题的，因为在进行类型擦除的时候无法知道上限
class TestAnimals <T super Dog>{
    T anni;
    public TestAnimals(T anni) {
        this.anni = anni;
    }
    public void test() {
        anni.say();
    }
}

但是使用泛型的时候，可以使用?来定义接受参数的上限和下限。
尽管使用通配符?，但是在具体的一次使用中还是只能有一个确定的类型。

        List<?> listOrg1 = null;
        List<Integer> list1 = new ArrayList<>();
        List<Object> list2 = new ArrayList<>();        
        listOrg1 = list1; 
        listOrg1 = list2;
        //可以对已经赋过值得泛型变量重新赋值，在
        //具体一次使用泛型变量的过程中还是只有一个
        //具体的类型。

        List<? super Number> listOrg1 = null;
        List<Integer> list1 = new ArrayList<>();
        List<Object> list2 = new ArrayList<>();        
        listOrg1 = list1; //编译错误
        listOrg1 = list2;
        
        List<? extends Number> listOrg2 = null;
        List<Integer> list3 = new ArrayList<>();
        List<Object> list4 = new ArrayList<>();
        listOrg2 = list3;
        listOrg2 = list4;//编译错误