对泛型深入浅出的认识
最近终于开始总结自己理解的东西，终于有时间写写自己对一些知识的认识。文笔不好，还望各位包含。以下知识点是我看了享学课堂的资料，对其中的内容进行汇总。
本预先资料来源于Oracle官方文档Java™ 教程-Java Tutorials
官方文档:https://docs.oracle.com/javase/tutorial/java/generics/index.html
中文翻译:https://pingfangx.github.io/java-tutorials/java/generics/types.html
下面我以问题的方式，阐明对泛型深入浅出的认识：
1.泛型是什么？
答：泛型是JDK5引入的一种参数化类型特性。JDK7及以上，泛型的菱形可以推断参数化类型：把类型当参数一样传递。数据类型只能是引用类型。
举个栗子：Plate<T>中的T是类型参数；Plate<Banana>的Banana是实际类型参数；
Plate<T>整个称为泛型类型；Plate<Banana>整个称为参数化的类型；
2.为什么使用泛型，使用泛型的好处？
答：1.代码更健壮（只要在编译器没有警告，运行期就不会出现ClassCastException）；
2.代码更简洁(不用强转)
3.代码更灵活，可复用。
3.泛型包含哪些？
答：泛型只有三种情况：泛型接口，泛型类，泛型方法
//泛型接口
public interface Plate<T> {
public void set(T t);
public T get();
}
//泛型类
public class AiPlate<T> {
private T t;
public AiPlate(T t){
this.t = t;
}
public void set(T t){
this.t = t;
}
public T get(){
return t;
}
//泛型方法
public <U> void addFruit(U u) {
}
}
4.泛型限定有哪些？
答：？无限定 ； extends 限定上界；super 限定下界 后面会以一个通熟易懂的口诀演示记住他
Class A {}
Class B {}
Interface C{}
Interface D{}
public class ClassTest<T extends A & C & D>{} //this is ok 可以实现多个接口
public class ClassTest<T extends A & B & C & D> //error, 因为java 只支持单继承
在这个体系中，上界通配符 “Plate<？ extends Fruit>” 覆盖下图中蓝色的区域。
Plate<? super Fruit>是Plate<Fruit>的基类，但是不是Plate<Apple>的基类，对应上面例子，Plate<? super Fruit>覆盖的下图中红色的区域
5.JAVA泛型的原理？什么是泛型擦除机制？
答：Java的泛型是JDK5新引入的特性，为了向下兼容，虚拟机其实是不支持泛型，所以Java实现的是一种伪泛型机制，也就是说Java在编译期擦除了所有的泛型信息，这样Java就不需要产生新的类型到字节码，所有的泛型类型最终都是一种原始类型，在Java运行时根本就不存在泛型信息。
泛型的擦除机制：如果有父类被擦除成父类，否则被擦除成Object。如果有继承，擦除之后会生成桥接方法，来解决类型擦除后保留泛型类型的多态性；桥方法在调用父类方法前，会将object进行强转成父类。
从 .java文件编译到.class文件会产生泛型擦除的残留，保留了定义的格式，方便分析字节码。类的常量池保留了泛型信息，可以通过反射API拿出type类型信息。
6.Java编译器具体是如何擦除泛型的？
答：step 1. 检查泛型类型，获取目标类型
step 2. 擦除类型变量，并替换为限定类型
如果泛型类型的类型变量没有限定(<T>),则用Object作为原始类型
如果有限定(<T extends XClass>),则用XClass作为原始类型
如果有多个限定(T extends XClass1&XClass2),则使用第一个边界XClass1作为原始类
step 3. 在必要时插入类型转换以保持类型安全
step 4. 生成桥方法以在扩展时保持多态性
7.使用了泛型，后留下很多“后遗症”
7.1 泛型类型变量不能使用基本数据类型
答：比如没有ArrayList<int>,只有ArrayList<Integer>.当类型擦除后，ArrayList的原始类中的类型变量(T)替换成Object,但Object类型不能存放int值
7.2 不能使用instanceof 运算符
答：因为擦除后，ArrayList<String>只剩下原始类型，泛型信息String不存在了，所有没法使用instanceof
ArrayList<String> strings = new ArrayList<>();
if(strings instanceof ArrayList<?>){} //可以 被擦除之后的ArrayList本来就是未知的，所以这个可以
if(strings instanceof ArrayList<String>) //不可以
7.3 泛型在静态方法和静态类中的问题
答：因为泛型类中的泛型参数的实例化在定义泛型类型对象(比如ArrayList<Integer>)的时候指定的，而静态成员是不需要使用对象来调用的，所有对象都没创建，编译器不知道如何确定这个泛型参数是什么。
7.4 泛型类型中的方法可能会冲突
答：因为擦除后两个equals方法变成一样的了。擦除之后T变成Object，而Object中的equals是默认被实现了的。所以重复了。
public boolean equals(T t){
return super equals(t)
}
public boolean equals(Object obj){
return super equals(obj)
}
7.5 没法创建泛型实例
答：因为类型不确定，没法直接new对象。
public static <E> void append(List<E> list){
E elem = new E（）; //不行，因为不知道E的具体类型
}
但是下面这种方式是可以的，通过反射来new对象；
public static <E> void append(List<E> list, Class<E> cls) throws Exception{
E elem = cls.newInstance（）; // OK
list.add(elem);
}
7.6 没有泛型数组
答：因为数组可以协变，擦除后就没法满足数组协变的原则。
T[] arr = new T[10] //不可以 不知道T代表那个类
另外：Apple extends Fruit
Apple[] 的父类是Fruit[] 这个叫数组的协变。
其中数组协变中：父类可以持有子类，子类持有父类可能会报转化异常。
List<Apple> 和 List<Fruit>在擦除之后运行期不知道是什么类型了，都是不满足协变原则了；数组是可以协变的，但是list是不会协变的。
另外假如：A extends B
Plate<B> = Plate<A>是不允许的，因为在泛型中，不管AB是什么关系，Plate<A>和Plate<B>没有任何关系。
8.通配符和泛型的关系？
答：通配符可以让泛型转化更灵活。
9.说出以下类型的区别?
Plate 普通的盘子类，编译时不会做类型检查
Plate<Object> 参数化的plate类，他在编译之后，字节码的类中的方法是Object
Plate<?> 非限定通配符下的泛型类，泛型？表示类型未知，等价于Plate<? extends Object>
Plate<T> 泛型Plate类，T是未知类型，编译后会被擦除成Object对象
Plate<? extends T> 限定上界的泛型类
Plate<? super T> 限定下界的泛型类
10.泛型边界的熟记口诀：
*extends 上界
* super 下界
* 说明：以下方便记忆的：“上”表示父类，“下”表示子类
* 口诀：
* 上界只可往上读，往上赋值；方法只能传递自己或者子类
* 下界只可向下写，向下赋值；方法只能传递自己或者父类
验证口诀的正确性：
import java.util.ArrayList;
import java.util.List;
/** * extends 上界
* super 下界
* 说明：以下方便记忆的：“上”表示父类，“下”表示子类
* 口诀：
* 上界只可往上读，往上赋值；方法只能传递自己或者子类
* 下界只可向下写，向下赋值；方法只能传递自己或者父类
* * 类关系： apple extends fruit extends food */
public class TestBoundary {
public static void main(String[] args) {
//演示extends赋值的上界
List<Food> foods = new ArrayList<>();
List<Apple> apples = new ArrayList<>();
List<Fruit> fruits = new ArrayList<>();
//fruits = apples; //error 往上赋值需要 extends
List<? extends Fruit> fruits1 = apples; //向上赋值成功
//演示向上读取
Fruit fruit = fruits1.get(0); //ok 上界修饰的可以往上读
Food food = fruits1.get(0); //ok 上界修饰的可以往上读
Object object = fruits1.get(0); //ok 上界修饰的可以往上读
//Apple apple = fruits1.get(0); //error 不能往下读
//演示方法传递
eat1(fruits); //ok 传递自己
eat1(apples); //ok 传递子类
//eat1(foods); //error 传递了父类
//演示Super赋值的下界
List<Food> foodsLower = new ArrayList<>();
List<Apple> applesLower = new ArrayList<>();
List<Fruit> fruitsLower = new ArrayList<>();
//fruitsLower = foodsLower; //error 往下赋值需要super修饰
List<? super Fruit> fruitList = foodsLower; // 向下赋值ok了
//演示向下写
fruitList.add(new Apple(1)); //用下写是ok的
//fruitList.add(new Food()); //error 用上写是不行的；
//演示下界方法只能传递自己或者父类
eat2(fruitsLower); //传递自己ok
eat2(foodsLower); // 传递父类ok
//eat2(applesLower); //传递子类error
}
public static <T> void eat1(List<? extends Fruit> fruits){
}
public static <T> void eat2(List<? super Fruit> fruits){
}
}
11.最后说了半天规则，用实例演示以下泛型有什么用处
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* 泛型的简单应用
* 从没用泛型慢慢演进 */
public class Test {
//普通不使用泛型的方法。
//有个需求需要把香蕉或者更多水果copy一下，难道需要重新写N个copy方法么？
//答案不是的，出现了泛型copy2
public static void copy1(List<Apple> dest,List<Apple> src){
Collections.copy(dest,src);
}
//现在可以把无数多相同的水果相互copy了，但是又有一个需求了
//现在苹果是确定了的，我想想找一个水果list把苹果放进去，于是就出现了copy3
public static <T> void copy2(List<T> dest,List<T> src){
Collections.copy(dest,src);
}
//现在找到一个水果list放苹果了。但是现在还有一个需求
//就是现在水果list确定了，我要放的水果不确定，于是有了copy4
public static <T> void copy3(List<? super T> dest,List<T> src){
Collections.copy(dest,src);
}
//这个就是Collections.copy的终极用法了。
//public static <T> void copy(@RecentlyNonNull List<? super T> dest, @RecentlyNonNull List<? extends T> src)
public static <T> void copy4(List<? super T> dest,List<? extends T> src){
Collections.copy(dest,src);
}
public static void main(String[] args) {
//新建两个苹果list
List<Apple> apples = new ArrayList<>();
apples.add(new Apple(1));
List<Apple> apples1 = new ArrayList<>();
apples1.add(new Apple(2));
//新建两个香蕉list
List<Banana> bananas = new ArrayList<>();
bananas.add(new Banana(1));
List<Banana> bananas1 = new ArrayList<>();
bananas1.add(new Banana(2));
//新建水果list
List<Fruit> fruits = new ArrayList<>();
fruits.add(new Apple(10)) ; // 先要告诉编译器fruit是放的苹果，否者copy3的dest参数编译器不知道放什么
//普通方法
copy1(apples,apples1);
//使用泛型方法
copy2(bananas,bananas1);
//苹果往水果盘子放
Test.<Apple>copy3(fruits,apples);
//注意这里苹果是确认的了
//水果list确定了放任意水果
Test.<Fruit>copy4(fruits,apples);
}
}
最后非常感谢各位能看完，希望对大家有收获，欢迎留言一起交流
