最近复习到泛型，才发现之前对泛型的了解仅仅停留在表面，在CSDN中也有很多大佬发的很好的文章，我在这也记录一下我自己的学习过程，有错误请大家指出。本文参考Java泛型详解 Java泛型详解
什么是泛型
在了解什么是泛型之前，我们先观察Java标准库提供的ArrayList，他可以看作“可变长度”数组。
实际上ArrayList内部就是一个Object[]数组，配合存储一个当前分配的长度，就可以充当“可变数组”
public class ArrayList {
private Object[] array;
private int size;
public void add(Object e) { ...}
public void remove(int index) { ...}
public Object get(int index) { ...}
}
如果上述ArrayList存储String类型，会出现几个缺点：
1、需要强制转型
2、不方便，容易出错
例如，代码必须这么写：
ArrayList list = new ArrayList();
list.add("Hello");
// 获取到Object，必须强制转型为String:
String first = (String) list.get(0);
很容易出现ClassCastException，因为容易“误转型”：
list.add(new Integer(123));
// ERROR: ClassCastException:
String second = (String) list.get(1);
要解决上诉问题，我们可以给String单独编写一种ArrayList：
public class StringArrayList {
private String[] array;
private int size;
public void add(String e) { ...}
public void remove(int index) { ...}
public String get(int index) { ...}
}
这样一来，存入的必须是String类型，取出的一定也是String类型。如果要存储integer呢，也要为Integer单独编写一个ArrayList。对于其他的class也是一样，我们都要为他们单独编写一个ArrayList，当然，这是不可能的，Java中的class有成百上千个。那这个要怎么解决呢？
为了解决这个问题，我们必须把ArrayList变成一种模板：ArrayList< T >：
public class ArrayList<T> {
private T[] array;
private int size;
public void add(T e) { ...}
public void remove(int index) { ...}
public T get(int index) { ...}
}
T可以是任何class，这样我们就可以解决上诉问题了。
// 创建可以存储String的ArrayList:
ArrayList<String> strList = new ArrayList<String>();
// 创建可以存储Float的ArrayList:
ArrayList<Float> floatList = new ArrayList<Float>();
// 创建可以存储Person的ArrayList:
ArrayList<Person> personList = new ArrayList<Person>();
所以，泛型就是定义一种模板，例如ArrayList< T >，然后在代码中为用到的类创建对应的ArrayList<类型>:
ArrayList<String> strList = new ArrayList<String>();
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。
为什么要用泛型
Java语言引入泛型的好处是安全简单。可以将运行时错误提前到编译时错误。
在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率
泛型的使用
泛型有三种使用方式，分别为：泛型接口、泛型类、泛型方法
泛型接口
除了ArrayList< T> 使用了泛型，还可以在接口中使用泛型。如：Arrays.sort(Object[])可以对任意数组进行排序，但排序的元素必须实现Comparable< T>这个泛型接口：
public interface Comparable<T> {
int compareTo(T o);
}
实例：
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
Person[] ps = new Person[] {
new Person("Bob", 61),
new Person("Alice", 88),
new Person("Lily", 75),
};
Arrays.sort(ps);
System.out.println(Arrays.toString(ps));
}
}
class Person implements Comparable<Person> {
String name;
int score;
Person(String name, int score) {
this.name = name;
this.score = score;
}
public int compareTo(Person other) {
return this.name.compareTo(other.name);
}
public String toString() {
return this.name + "," + this.score;
}
}
//结果可以正确实现按name进行排序
泛型类
泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。（这几个是集合的知识，我到时也会贴出来）
那我们要怎么编写一个泛型类呢？编写泛型类比普通类要复杂。通常来说，反省类一般用于集合类中。例如ArrayList< T > ，其实，我们平时很少需要编写泛型类。
首先，按照某种类型，例如：String，来编写类：
public class Test {
private String first;
private String last;
public Pair(String first, String last) {
this.first = first;
this.last = last;
}
public String getFirst() {
return first;
}
public String getLast() {
return last;
}
}
然后将特定类型String替换为T，并申明< T >：
public class Test<T> {
private T first;
private T last;
public Test(T first, T last) {
this.first = first;
this.last = last;
}
public T getFirst() {
return first;
}
public T getLast() {
return last;
}
}
编写泛型类时，要特别注意，泛型类型不能用于静态方法。
public class Pair<T> {
private T first;
private T last;
public Pair(T first, T last) {
this.first = first;
this.last = last;
}
public T getFirst() { ... }
public T getLast() { ... }
// 对静态方法使用<T>:
public static Pair<T> create(T first, T last) {
return new Pair<T>(first, last);
}
}
对于静态方法，我们可以单独改写为“泛型”方法，只需要使用另一个类型即可。对于上面的create()静态方法，我们应该把它改为另一种泛型类型，例如，：
public class Pair<T> {
private T first;
private T last;
public Pair(T first, T last) {
this.first = first;
this.last = last;
}
public T getFirst() { ... }
public T getLast() { ... }
// 静态泛型方法应该使用其他类型区分:
public static <K> Pair<K> create(K first, K last) {
return new Pair<K>(first, last);
}
}
这样才能清楚地将静态方法的泛型类型和实例类型的泛型类型区分开
多个泛型类型
泛型还可以定义多种类型，例如，我们希望Test不总是存储两个类型一样的对象，就可以使用类型<T, K>:
public class Test<T, K> {
private T first;
private K last;
public Test(T first, K last) {
this.first = first;
this.last = last;
}
public T getFirst() { ... }
public K getLast() { ... }
}
使用的时候，需要指出两种类型：
Test<String, Integer> p = new Test<>("test", 123);
泛型方法
泛型方法使得该方法能独立于类而产生变化。以下是一个基本的指导原则：无论何时，只要你能做到，你就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛型化，那么就应该只使用泛型方法，因为它可以使事情更清楚明白。另外，对于一个static的方法而言，无法访问泛型类的类型参数。所以，如果static方法需要使用泛型能力，就必须使其成为泛型方法。
要定义泛型方法，只需将泛型参数列表置于返回值之前，就像下面这样：
package Generics;
public class GenericMethods {
//当方法操作的引用数据类型不确定的时候，可以将泛型定义在方法上
public <T> void f(T x){
System.out.println(x.getClass().getName());
}
public static void main(String[] args) {
GenericMethods gm = new GenericMethods();
gm.f(99);
gm.f("我是一个Java小白");
gm.f(new Integer(99));
gm.f(18.88);
gm.f('a');
gm.f(gm);
}
}
泛型的擦拭
泛型是一种类似”模板代码“的技术，不同语言的泛型实现方式不一定相同。Java语言的泛型实现方式是擦拭法（Type Erasure）。所谓擦拭法是指，虚拟机对泛型其实一无所知，所有的工作都是编译器做的。
例如，我们编写了一个泛型类Test< T >，这是编译器看到的代码：
public class Test<T> {
private T first;
private T last;
public Test(T first, T last) {
this.first = first;
this.last = last;
}
public T getFirst() {
return first;
}
public T getLast() {
return last;
}
}
二虚拟机根本不知道泛型，这是虚拟机看到的：
public class Test{
private Object first;
private Object last;
public Test(Object first, Object last) {
this.first = first;
this.last = last;
}
public Object getFirst() {
return first;
}
public Object getLast() {
return last;
}
}
因此，Java使用擦拭法实现泛型，导致了：
- 编译器把类型视为Object；
- 编译器根据实现安全的强制转型。
了解了Java泛型的实现方式——擦拭法，我们就知道了Java泛型的局限：
局限一：< T>不能是基本类型，例如int，因为实际类型是Object，Object类型无法持有基本类型：
Test<int> p = new Test<>(1, 2); // compile error!
局限二：无法取得带泛型的Class。观察以下代码：
public class Main {
public static void main(String[] args) {
Test<String> p1 = new Test<>("Hello", "world");
Test<Integer> p2 = new Test<>(123, 456);
Class c1 = p1.getClass();
Class c2 = p2.getClass();
System.out.println(c1==c2); // true
System.out.println(c1==Test.class); // true
}
}
class Test<T> {
private T first;
private T last;
public Test(T first, T last) {
this.first = first;
this.last = last;
}
public T getFirst() {
return first;
}
public T getLast() {
return last;
}
}
因为T是Object，我们对Test< String>和Test< Integer>类型获取Class时，获取到的是同一个Class，也就是Test类的Class。
换句话说，所有泛型实例，无论T的类型是什么，getClass()返回同一个Class实例，因为编译后它们全部都是Test< Object>。
局限三：无法判断带泛型的类型：
Test<Integer> p = new Test<>(123, 456);
// Compile error:
if (p instanceof Test<String>) {
}
原因和前面一样，并不存在Test< String>.class，而是只有唯一的Test.class。
局限四：不能实例化T类型：
public class Test<T> {
private T first;
private T last;
public Test() {
// Compile error:
first = new T();
last = new T();
}
}
要实例化T类型，我们必须借助额外的Class< T>参数：
public class Test<T> {
private T first;
private T last;
public Test(Class<T> clazz) {
first = clazz.newInstance();
last = clazz.newInstance();
}
}
泛型的继承
一个类可以继承自一个泛型类。例如：父类的类型是Pair< Integer >，子类的类型时Intpair，可以这么继承：
public class IntPair extends Pair<Integer> {
}
使用的时候，因为子类Intpair并没有泛型类，所以，正常使用即可：
IntPair ip = new IntPair(1, 2);
前面讲了，我们无法获取Pair的T类型，即给定一个变量Pair p，无法从p中获取到T类型。
但是，在父类是泛型类型的情况下，编译器就必须把类型T（对IntPair来说，也就是Integer类型）保存到子类的class文件中，不然编译器就不知道IntPair只能存取Integer这种类型。
在继承了泛型类型的情况下，子类可以获取父类的泛型类型。例如：IntPair可以获取到父类的泛型类型Integer。获取父类的泛型类型代码比较复杂
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
public class Main {
public static void main(String[] args) {
Class<IntPair> clazz = IntPair.class;
Type t = clazz.getGenericSuperclass();
if (t instanceof ParameterizedType) {
ParameterizedType pt = (ParameterizedType) t;
Type[] types = pt.getActualTypeArguments(); // 可能有多个泛型类型
Type firstType = types[0]; // 取第一个泛型类型
Class<?> typeClass = (Class<?>) firstType;
System.out.println(typeClass); // Integer
}
}
}
class Pair<T> {
private T first;
private T last;
public Pair(T first, T last) {
this.first = first;
this.last = last;
}
public T getFirst() {
return first;
}
public T getLast() {
return last;
}
}
class IntPair extends Pair<Integer> {
public IntPair(Integer first, Integer last) {
super(first, last);
}
}
extends和super通配符
我们在定义泛型类，泛型方法，泛型接口的时候经常会碰见很多不同的通配符，比如 T，E，K，V 等等，这些通配符又都是什么意思呢？
常用的 T，E，K，V，？
本质上这些个都是通配符，没啥区别，只不过是编码时的一种约定俗成的东西。比如上述代码中的 T ，我们可以换成 A-Z 之间的任何一个 字母都可以，并不会影响程序的正常运行，但是如果换成其他的字母代替 T ，在可读性上可能会弱一些。通常情况下，T，E，K，V，？是这样约定的：
- T (type) 表示具体的一个java类型
- K V (key value) 分别代表java键值中的Key Value
- E (element) 代表Element
- ? 无限定通配符类型
<? extends T> 表示类型的上界（也叫子类型限定通配符），表示参数化类型的可能是T 或是 T的子类
<? super T> 表示类型下界（Java Core中叫超类型限定通配符），表示参数化类型是此类型的超类型（父类型），直至Object
通配符使用场景
上限：？extends E：可以接收E类型或者E的子类型对象。
下限：？super E：可以接收E类型或者E的父类型对象。
上限什么时候用：往集合中添加元素时，既可以添加E类型对象，又可以添加E的子类型对象。为什么？因为取的时候，E类型既可以接收E类对象，又可以接收E的子类型对象。
下限什么时候用：当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。
通配符只有在修饰一个变量或参数的时候会用到，在定义泛型类或泛型方法的时候是不能使用通配符的。
为了更好的说明泛型通配符的使用，我们使用代码示例来加以说明。首先我们创建一个类 Test，是一个泛型类，里面保存一个变量 one
public class Test<T> {
private T One;
// 省略 get 和 set 方法
// ......
}
我们再创建两个类 Father 和 Son，Son 是 Father 的子类
// Father.java
public class Father {
}
// Son.java
public class Son extends Father{
}
如果我们按照小面的写法，程序将会报错：
public static void main(String[] args){
Test<Father> a1 = new Test<Father>();
Test<Son> a2 = new Test<Son>();
test1(a1);
test1(a2); // 编译错误
}
public void test1(Test<Father> a){ ...}
这是为什么？因为虽然Son 是 Father 的子类，但 test1(Test a) 方法却不能接收参数 a2，也就是说 Test 不是 Test 的子类。这个时候就可以使用通配符来解决，我们修改 test1 方法。
public static void main(String[] args){
Test<Father> a1 = new Test<Father>();
Test<Son> a2 = new Test<Son>();
test1(a1);
test1(a2);
}
public void test1(Test<? extends Father> a){ ...}
这样可以可以正常调用，说明类型 A 是 A<? extends Father> 的子类型。
<? extends E> 通配符
用 extends 关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。
在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类，这样有两个好处：
- 如果传入的类型不是 E 或者 E 的子类，编译不成功
- 泛型中可以使用 E 的方法，要不然还得强转成 E 才能使用
private <K extends A, E extends B> E test(K arg1, E arg2){
E result = arg2;
arg2.compareTo(arg1);
//.....
return
result;
}
类型参数列表中如果有多个类型参数上限，用逗号分开
使用extends通配符表示可以读，不能写。
< ? super E>通配符
用 super 进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至 Object
在类型参数中使用 super 表示这个泛型中的参数必须是 E 或者 E 的父类。
private<T> void test(List<? superT> dst, List<T> src){
for(T t : src) {
dst.add(t);
}
}
public static void main(String[] args) {
List <Dog> dogs = new ArrayList<>();
List <Animal> animals = new ArrayList<>();
new Test3().test(animals,dogs);
}
// Dog 是 Animal 的子类
class Dog extends Animal{ }
?和T的区别
T 是一个 确定的 类型，通常用于泛型类和泛型方法的定义，？是一个 不确定 的类型，通常用于泛型方法的调用代码和形参，不能用于定义类和泛型方法。
- 区别1：通过 T 来 确保 泛型参数的一致性
// 通过 T 来 确保 泛型参数的一致性
public <T extends Number> void
test(List<T> dest, List<T> src)
//通配符是 不确定的，所以这个方法不能保证两个 List 具有相同的元素类型
public void test(List<? extends Number> dest, List<? extends Number> src)
像下面的代码中，约定的 T 是 Number 的子类才可以，但是申明时是用的 String ，所以就会飘红报错。
不能保证两个 List 具有相同的元素类型的情况
Test<String> test= new Test<>();
List<String> dest = new ArrayList<>();
List<Number> src = new ArrayList<>();
test.testNon(dest,src)
上面的代码在编译器并不会报错，但是当进入到 testNon 方法内部操作时（比如赋值），对于 dest 和 src 而言，就还是需要进行类型转换
- 区别2：类型参数可以多重限定而通配符不行
public class Test implements A, B {
public static<T extends A & B> void test(T t){
}
}
interface A{ }
interface B{ }
使用 & 符号设定多重边界（Multi Bounds)，指定泛型类型 T 必须是 A和 B的共有子类型，此时变量 t 就具有了所有限定的方法和属性。对于通配符来说，因为它不是一个确定的类型，所以不能进行多重限定
- 区别3：通配符可以使用超类限定而类型参数不行
类型参数 T 只具有 一种 类型限定方式：
T extends A
但是通配符 ? 可以进行 两种限定：
? extends A
? super A
Class< T > 和 Class< ? > 区别
最常见的是在反射场景下的使用，这里以用一段发射的代码来说明下。
// 通过反射的方式生成 one
// 对象，这里比较明显的是，我们需要使用强制类型转换
One one= (One)
Class.forName("com.glmapper.bridge.boot.generic.One").newInstance();
对于上述代码，在运行期，如果反射的类型不是 One类，那么一定会报 java.lang.ClassCastException 错误。
对于这种情况，则可以使用下面的代码来代替，使得在在编译期就能直接 检查到类型的问题：
public class Test2{
public static <T> T creaeIntance(class<T> clazz) throws IllegalAccessException, InstantiationException{
return clazz.newIntance();
}
public statci void main(String[] args) throws IllegalAccessException, InstantiationException {
A a = creaeIntance(A.class);
B b = creaeIntance(B.class);
}
}
class A{ }
class B{ }
Class< T> 在实例化的时候，T 要替换成具体类。Class<?> 它是个通配泛型，? 可以代表任何类型，所以主要用于声明时的限制情况。比如，我们可以这样做申明：
// 可以
public Class<?> clazz;
// 不可以，因为 T 需要指定类型
public Class<T> clazzT;
所以当不知道定声明什么类型的 Class 的时候可以定义一 个Class<?>。
public class Test2<T>{
public class<?> clazz;
对比extends和super通配符
<? extends T>类型和<? super T>类型的区别在于：
<? extends T>允许调用读方法T get()获取T的引用，但不允许调用写方法set(T)传入T的引用（传入null除外）
<? super T>允许调用写方法set(T)传入T的引用，但不允许调用读方法T get()获取T的引用（获取Object除外）
一个是允许读不允许写，另一个是允许写不允许读。
我感觉个人的写文章水平确实挺差劲的，自己大概懂得是咋回事，但是就是挺难表达出来的，所以对于泛型这篇文章，我写了好久好久，也在网上看了很多大佬的文章，感觉他们都很厉害，让我受益匪浅，我也是按照那些大佬的思路来写的，虽然文章里借鉴了许多大佬的成果，但是只要把这些知识消化了，就是自己得了。这篇文章挺长的，虽然我有想分为两部分发，但是我怕有些人并不会去看下一篇，而且在同一篇以后复习起来也比较容易点。
