一、泛型理解
泛型即类型参数化，把具体的类型参数化，在使用/调用时传入具体的类型，可用在类、接口、方法中，分别称为泛型类、泛型接口、泛型方法，作用简单点说就是“参数类型约束”。
二、为什么要有泛型？
不使用泛型：
List list = new ArrayList();
list.add("a");
list.add(1);
for (int i = 0; i < list.size(); i++) {
String item = (String) list.get(i);
System.out.println("item=" + item);
}
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
为了解决类似上面的问题（在编译阶段就可以解决），泛型应运而生。
另外，在实际的编程过程中，自己可以使用泛型去简化开发，且能很好的保证代码质量。
使用泛型：
在编译阶段，编译器就会报错。
三、泛型特性
泛型必须是类类型，不能是基本数据类型。只在编译阶段有效，编译之后会被去泛型化，即泛型擦除。
总结：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。
四、泛型类
定义：
//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{
//key这个成员变量的类型为T,T的类型由外部指定
private T key;
public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
this.key = key;
}
public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
return key;
}
}
使用：在实例化类的时候指明泛型的具体类型
//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
Generic<Integer> genericInteger = new Generic<Integer>(1);
//传入的实参类型需与泛型的类型参数类型相同，即为String.
Generic<String> genericString = new Generic<String>("a");
注意：
- 定义的泛型类，就一定要传入泛型类型实参么？并不是这样，在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。
- 不能对确切的泛型类型使用instanceof操作。
五、泛型接口
定义：
//定义一个泛型接口
public interface Generator<T> {
public T next();
}
使用：
/**
* 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
* 即：class FruitGenerator<T> implements Generator<T>{
* 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"
*/
class FruitGenerator implements Generator<String>{
@Override
public String next() {
return null;
}
}
/**
* 传入泛型实参时：
* 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
* 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
* 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
* 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。
*/
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)];
}
}
六、泛型方法
定义：
/**
* 泛型方法的基本介绍
*
* @param tClass 传入的泛型实参
* @return T 返回值为T类型
* 说明：
* 1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
* 2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
* 3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
* 4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
*/
public <T> T genericMethod(Class<T> tClass) throws InstantiationException,
IllegalAccessException {
T instance = tClass.newInstance();
return instance;
}
使用：
Object obj = genericMethod(Class.forName("com.test.test"));
特殊用法：
1.在泛型类中定义泛型方法
class GenerateTest<T> {
public void show_1(T t) {
System.out.println(t.toString());
}
//在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
//由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
public <E> void show_3(E t) {
System.out.println(t.toString());
}
//在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
public <T> void show_2(T t) {
System.out.println(t.toString());
}
}
2.泛型方法与可变参数
public <T> void printMsg(T... args) {
for (T t : args) {
System.out.println("t is " + t);
}
}
printMsg("1", 2, "a", "3.14", 4.88);
3.静态方法与泛型
静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。 即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法 。
public class StaticGenerator<T> {
/**
* 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
* 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
* 如：public static void show(T t){..},此时编译器会提示错误信息：
* "StaticGenerator cannot be refrenced from static context"
*/
public static <T> void show(T t) {
}
}
总结： 泛型方法能使方法独立于类而产生变化，以下是一个基本的指导原则：
无论何时，如果你能做到，你就该尽量使用泛型方法。也就是说，如果使用泛型方法将整个类泛型化，那么就应该使用泛型方法。另外对于一个static的方法而已，无法访问泛型类型的参数。所以如果static方法要使用泛型能力，就必须使其成为泛型方法。
七、泛型通配符（？）
为何要有泛型通配符？
同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
public void showKeyValue(Generic<Number> obj){
System.out.println("key value is " + obj.getKey());
}
Generic<Integer> genericInteger = new Generic<Integer>(1);
Generic<Number> genericNumber = new Generic<Number>(2);
Generic<String> genericString = new Generic<String>("a");
showKeyValue(genericNumber);
// showKeyValue这个方法编译器会报错：Generic<java.lang.Integer>
// cannot be applied to Generic<java.lang.Number>
// showKeyValue(genericInteger);
用法：
public void showKeyValue(Generic<?> obj){
System.out.println("key value is " + obj.getKey());
}
总结：
- 类型通配符一般是使用“？”代替具体的类型实参，注意了，此处“？”是类型实参，而不是类型形参 。重要的事情说三遍！此处“？”是类型实参，而不是类型形参！此处“？”是类型实参，而不是类型形参！再直白点的意思就是，此处的“？”和Number、String、Integer一样都是一种实际的类型，可以把“？”看成所有类型的父类。是一种真实的类型。
- 可以解决当具体类型不确定的时候，且不需要使用类型的具体功能，只使用Object类中的功能。那么可以用“？”通配符来表示未知类型。
八、泛型的上下边界
在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。
上边界：
1.作用在方法参数上
public void showKeyValue(Generic<? extends Number> obj){
System.out.println("key value is " + obj.getKey());
}
2.作用在泛型类声明上
public class Generic<T extends Number> {
private T key;
public Generic(T key) {
this.key = key;
}
public T getKey() {
return key;
}
}
3.作用在泛型方法上
public <T extends Number> T showKeyName(Generic<T> container){
System.out.println("container key :" + container.getKey());
T test = container.getKey();
return test;
}
下边界：
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));
}
总结：
泛型的上下边界添加，必须与泛型的声明在一起 。
