前提
专业术语有时候比较难懂，
胖子觉得，用不严谨的说法，泛型的白话解释就是：
传入的任意对象（注意是对象）
泛型一般有三种：泛型类、泛型接口、泛型方法
泛型类：典型泛型类---ArrayList
public class A<T> {
private T data;
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}
//这样可以
A<Integer> a1 = new A();
A<String> a2 = new A();
//这样不行
A<int> a3 = new A();
泛型接口：典型泛型接口---List
public interface IA<T> {
T next();
}
//第一种
public class A<T> implements IA<T> {
@Override
public T next() {
return null;
}
}
//第二种
public class A implements IA<String> {
@Override
public String next() {
return null;
}
}
泛型方法：典型的泛型方法---Objects下的requireNonNull
public static <T> T requireNonNull(T var0) {
if (var0 == null) {
throw new NullPointerException();
} else {
return var0;
}
}
//使用
Integer integer = null;
Objects.requireNonNull(integer);//这里会抛一个NullPointerException
敲黑板
泛型里，最烧脑的，应该属于extends、super了。
说到底，extends、super其实就是用来约束传入的泛型的
比如：
extends
//<T extends 可以多个>，
//规则：
//<T extends 类&接口&接口>,类有且只能有一个，接口可以有多个。有类的情况下，类必须是第一个
public class AClass<T> {
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
};
-------
public class BClass{};
public class CClass extends BClass{};
-----
public class DClass{};
-----
public static void print(AClass<? extends BClass> par) {
}
//使用
AClass<CClass> cClass = new AClass();
AClass<BClass> bClass = new AClass();
AClass<DClass> dClass = new AClass();
print(cClass);
print(bClass);
print(dClass);//编译不通过。因为DClass不是BClass的派生类
//接着
AClass<? extends BClass> aClass = new AClass();
BClass bClass1 = new BClass();
CClass cClass1 = new CClass();
aClass.setT(bClass1);//编译不通过。因为set时，编译器只知道set的是BClass的子类，但具体是哪一个子类，编译器是无法知道的。
aClass.setT(cClass1);//编译不通过。
BClass bClass = aClass.getT();//这样可以。因为插入的肯定是BClass的派生类
为什么呢？请了解PECS原则
PECS原则全称"Producer Extends, Consumer Super"，即上界生产，下界消费。
通俗点：频繁往外读取内容的，适合用上界Extends
super
public static void main(String[] args) {
AClass<BClass> bClass = new AClass();
AClass<CClass> cClass = new AClass();
print(bClass);
print(cClass);//编译错误。CClass不是BClass的超类
//再来
AClass<? super BClass> bClass = new AClass();
bClass.setT(new CClass());
bClass.setT(new BClass());
bClass.setT(new Object());//这里编译错误。因为如果插入的是BClass的超类，编译器就无法安全的转型为BClass。
Object t = bClass.getT();//可以get，但是返回的是Object。因为编译器没办法知道返回的是什么超类，但是可以确定，肯定是Object的子类
//这里胖子有疑问？
//既然jdk限制不让set超类，那get时，不就可以返回最上级的父类类吗？为什么还是返回Object呢？
//有大神知道，可以告知小弟一下。
//PECS原则全称"Producer Extends, Consumer Super"，即上界生产，下界消费。
//经常往里插入的，适合用下界Super
}
public static void print(AClass<? super BClass> par) {
System.out.println(par.getT());
}
最后
AClass<BClass> bClass = new AClass();
AClass<CClass> cClass = new AClass();
bClass和cClass没有什么实质性关系。在编译时，编译器会有一个叫“泛型擦除”，
执行 javap -c -s "路径"
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
Code:
0: new #2 // class com/java/basic/Generic/AClass
3: dup
4: invokespecial #3 // Method com/java/basic/Generic/AClass."<init>":()V
7: astore_1
8: new #2 // class com/java/basic/Generic/AClass
11: dup
12: invokespecial #3 // Method com/java/basic/Generic/AClass."<init>":()V
------
最后会变成：
AClass bClass = new AClass();
AClass cClass = new AClass();
结束
放空自己，重新出发。
