泛型知识概括@TOC 泛型简述泛型定义：泛型是一种安全机制所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某

@TOC

泛型简述

泛型定义：

泛型是一种安全机制
所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。
这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）

泛型的设计背景：

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，
JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，
因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。 ①Collection<E> ②List<E> ③ArrayList<E>
这个<E>就是类型参数，即泛型。

为什么要有泛型：

那么为什么要有泛型呢，直接Object不是也可以存储数据吗？ ①解决元素存储的安全性问题，好比商品、药品标签，不会弄错。 ②解决获取数据元素时，需要类型强制转换的问题，好比不用每回拿商品、药品都要辨别
在集合中没有泛型时:
在集合中有泛型时:

自定义泛型结构

自定义泛型类和接口简述：

泛型的声明：interface List 和 class GenTest<K,V> ①其中，T,K,V不代表值，而是表示类型。这里使用任意字母都可以。常用T表示，是Type的缩写。
泛型的实例化：一定要在类名后面指定类型参数的值（类型）。 ①如：List<String> strList = new ArrayList<String>(); ②Iterator<Customer> iterator = customers.iterator(); ③T只能是类，不能用基本数据类型填充。但可以使用包装类填充 ④把一个集合中的内容限制为一个特定的数据类型，这就是generics背后的核心思想

注意：

泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如： <E1,E2,E3>
泛型类的构造器如下：public GenericClass(){}。而下面是错误的：public GenericClass(){}
实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
泛型不同的引用不能相互赋值。
尽管在编译时ArrayList<String>和ArrayList<Integer>是两种类型，但是在运行时只有一个ArrayList被加载到JVM中。
泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
jdk1.7，泛型的简化操作：ArrayList flist = new ArrayList<>();
泛型的指定中不能使用基本数据类型，可以使用包装类替换。
在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。
异常类不能是泛型的
不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity]; 参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。
父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
①子类不保留父类的泛型：按需实现 1、没有类型擦除 2、具体类型 ②子类保留父类的泛型：泛型子类 1、全部保留 2、部分保留 ③结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型

自定义泛型方法：

方法，也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。
泛型方法的格式： [访问权限] <泛型> 返回类型方法名([泛型标识参数名称]) 抛出的异常

public class DAO {
	public <E> E get(int id, E e) {
		E result = null;
		return result; 
	} 
}

泛型在继承上的体现： 在这里插入图片描述

通配符的使用

简述：

使用类型通配符：？ ①比如：List ，Map ②List<?>是List、List等各种泛型List的父类。
读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，它包含的都是Object。
写入list中的元素时，因为我们不知道c的元素类型，我们不能向其中添加对象。

①将任意元素加入到其中不是类型安全的：

Collection<?> c = new ArrayList<String>();
c.add(new Object()); // 编译时错误

②因为我们不知道c的元素类型，我们不能向其中添加对象。add方法有类型参数E作为集合的元素类型。我们传给add的任何参数都必须是一个未知类型的子类。因为我们不知道那是什么类型，所以我们无法传任何东西进去。 ②唯一的例外是null，它是所有类型的成员。 ③另一方面，我们可以调用get()方法并使用其返回值。返回值是一个未知的类型，但是我们知道，它总是一个Object。

通配符的使用：有限制的通配符：

允许所有泛型的引用调用
通配符指定上限 ①上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=
通配符指定下限 ②下限super：使用时指定的类型不能小于操作的类，即>=
举例： ①<? extends Number> (无穷小 , Number] 只允许泛型为Number及Number子类的引用调用 ②<? super Number> [Number , 无穷大) 只允许泛型为Number及Number父类的引用调用 ③ <? extends Comparable> 只允许泛型为实现Comparable接口的实现类的引用调用

泛型的擦除和限制

类型擦除：

Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会在编译器在编译的时候去掉。这个过程就称为类型擦除。
泛型的相关信息可被编译器使用，但是这些信息在运行时是不可用的。
泛型仅仅存在于编译，一但编译器确认泛型类型的安全性，就会将它转换原生类型。
当编译泛型类、接口或方法时，编译器会用Object代替泛型类型。
当一个泛型受限时，编译器会用其首限类型替换它。
不管实际的具体类型是什么，泛型类总是被它的所有实例所共享。

类型擦除造成的限制：

不能使用泛型类型参数创建实例。 ①使用泛型类型参数创建实例时，会进行泛型擦除，底层new的是Object。
不能使用泛型类型参数创建数组。
不允许使用泛型类创建泛型数组。 ①使用泛型的作用是使得程序在编译期可以检查出与类型相关的错误，但是如果使用了泛型数组，这种能力就会受到破坏。
泛型类的所有实例具有相同的运行时类，所以泛型类的静态变量和方法时被它的实例们所共享的
异常类不能是泛型的。
链接：泛型的内部原理：类型擦除以及类型擦除带来的问题

--------Pair<T>的泛型类型为：-----------
class Pair<T> {
    private T value;
    public T getValue() {
        return value;
    }
    public void setValue(T  value) {
        this.value = value;
    }
}

--------Pair<T>的原始类型为：-----------
class Pair {
	private Object value;
	public Object getValue() {
		return value;
	}
	public void setValue(Object  value) {
		this.value = value;
	}
}

泛型总结

总结：

泛型擦除后底层就是Object，因此才可以存储各种类型。
泛型会在编译时进行检查。
若没有指定具体类型时，默认使用Object。
注意： ①泛型的出现在很大程度上是为了避免运行时出现烦人的 ClassCastException，可是具有讽刺意味的是，泛型数组却又导致了ClassCastException异常的出现。 ②静态方法不能使用类的泛型。 ③泛型里的自动转换： <1>链接：Java 深入理解泛型的强制转型及自动转型

--------------------Java代码：--------------------
import java.util.ArrayList;
public class Test<T>{
	private T obj;	
	public void set(T obj) {this.obj = obj;}	
	public T get() {return this.obj;}		
	public static void main(String[] args) {		
		Test<String> t = new Test<>();
		t.set("xixixi~");
		String str = t.get();
		System.out.println(str);	
	}		
}
--------------------字节码：----------------------
 0 new #1 <Test>
 3 dup
 4 invokespecial #30 <Test/<init>()V>
 7 astore_1
 8 aload_1
 9 ldc #31 <xixixi~>
11 invokevirtual #33 <Test/set(Ljava/lang/Object;)V>
14 aload_1
15 invokevirtual #35 <Test/get()Ljava/lang/Object;>
18 checkcast #37 <java/lang/String>   //注意这一行！！！
21 astore_2
22 getstatic #39 <java/lang/System/out Ljava/io/PrintStream;>
25 aload_2
26 invokevirtual #45 <java/io/PrintStream/println(Ljava/lang/String;)V>
29 return

-------------------因果结论：----------------------
注意字节码编号为18的这一行！checkcast指令为检测是否可以转换成
String并执行转换。为啥可以转换？你传的时候就是一个String当然可以
转换了！只不过擦除就相当于对你传入的String进行了一次向上转型到
Object，现在再自己向下转型回来。所以说，Java的泛型是一项安全技
术，在编译期检测你的类型不让你随意乱传递参数。

链接： ①3万字死磕Java泛型所有细节知识点，看这一篇就够了