本文转发自：https://blog.csdn.net/justloveyou_/article/details/52420071

本文目录：

一. 引子

二、泛型基础

三. 通配符及泛型的逆变和协变

四.编译器如何处理泛型？

五. 类型擦除

六. 泛型带来的问题及解决方法

七. 小结

一. 引子

一般的类和方法，只能使用具体类型：要么是基本类型，要么是自定义类型。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。

多态算是一种泛化机制，但对代码的约束还是太强（要么继承父类，要么实现接口）。有许多原因促成了泛型的出现，而最重要的一个原因，就是为了更安全友好的使用容器类 : 用来指定容器要持有什么类型的对象，而且由编译器来保证类型的正确性。

例如：在 Java 加入泛型特性前，ArrayList 只维护一个 Object 类型的数组：

public class ArrayList{
   private Object[] elementData;
   ...
   public Object get(int i){ ... }
   public void add(Object o){ ... }
   ...
}

显然，这样的实现存在两个问题： 　　

1. 当获取一个值时，必须进行强制类型转换：

   ArrayList list = new ArrayList();
   …
   String str = (String)list.get(0);

2. 该 ArrayList 没有错误检查，即可以向数组中添加任何类型的对象：

   list.add(new Integer(1));

向上述的动态数组中添加一个整型对象，程序在编译时和运行时都不会出错。但当我们强制将 get 结果转型时，就会抛出 ClassCastException 异常，程序出错。对于容器类，它是可以存储任何对象的，但我们在使用时，一次只想也只应该向其中放入一种对象。基于这种需求，提出了 类型参数化 的概念，即泛型。　

• 引入泛型后的 ArrayList 源码

  public class ArrayList extends AbstractList

                        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
      // ...

  }

二、泛型基础

1. 概念

1、术语：适用于许多许多的类型;

2、本质：实现类型参数化的概念，使代码可以应用于多种类型;

3、核心：告诉编译器想使用什么类型（指定具体类型参数或对其进行限制），然后编译器帮你处理一切细节(类型安全检查等);

4、泛型初衷：

(1). 希望类或方法具备最广泛的表达能力，即通过解耦类或方法与所使用的类型之间的约束；

(2). 对容器类而言，泛型在保证容器类可以存储任何类型对象的同时，又保证了容器类一旦声明自己将要保存的元素类型时，就不可再保存其他类型了，例如：

ArrayList<Fruit> list = new ArrayList<Fruit>();
fruits.add(new Fruit());       // OK
fruits.add(new Apple());       // OK
fruits.add(new Orange());      // OK
fruits.add(new Object());      // Error

上述代码表明了该容器只能保存 Fruit 类型的对象，由于 Apple 也是一种 Fruit，所以其也可以保存 Apple 类型 对象，但对于不属于 Fruit类型 的对象，编译器杜绝将其放入列表中。

简单地说：泛型 = 编译时的类型检查 + 编译时的类型擦除(编译器插入 checkcast 等) + 运行时的自动类型转换。**所以，我们在理解和应用泛型时，一定要从 编译期 和 运行时 两个视角去分析。**

• 例1：

在 Java 1.7 以后，我们可以这样创建一个 ArrayList：

ArrayList<String> list = new ArrayList<>();

list 变量的类型就决定了它引用的动态数组所能存储的元素类型，即后者的类型参数可以从变量中推断出。

• 例2：

  public class TypeInference {

  public static <E> Set<E> union(Set<? extends E> s1, Set<? extends E> s2) {
      Set<E> result = new HashSet<E>(s1);
      result.addAll(s2);
      return result;
  }
  public static void main(String[] args) {
      Set<Integer> integers = new HashSet<Integer>();
      Set<Double> doubles = new HashSet<Double>();
      Set<Number> numbers = null;
      // 编译器的类型推断能力有限
      numbers = TypeInference.union(integers, doubles);           // Error
      numbers = TypeInference.<Number>union(integers, doubles);   // OK
  }

  }

如例 2 所示，为 numbers 赋值时需要显式对类型参数实例化。

2. 定义与语法

• 泛型类（参数化类）

  public class Holder{}

• 泛型接口（参数化接口）

  public interface Generator{}

• 泛型方法（参数化方法：所在类可以是泛型类，也可以不是；能够独立于类而产生变化；细粒度）

  public void fun(T x){}

3. 注意事项

1. 泛型与多态

只有当你希望使用的参数类型比某个具体类型（以及它的所有子类型）更加泛化时，也就是说，当你的代码能够跨多个类工作时，使用泛型才有所帮助（比如开发中我们写的一个公共类，可以设置为泛型类）；否则，使用多态就可以满足要求。

public class HasF {
    public void f(){...}
}
// 以下两种实现方式所取得的效果是一样的
// 泛型实现
class Manipulator1<T extends HasF>{
    private T obj;
    public Manipulator1(T x){
        this.obj = x;
    }
    public void manipulate(){
        obj.f();
    }
}
// 多态实现
class Manipulator2{
    private HasF obj;
    public Manipulator2(HasF x){
        this.obj = x;
    }
    public void manipulate(){
        obj.f();
    }
}

2. 泛型类的识别（误区）

先看下面两段代码：

// 第一段代码
public class Pair<T> {
    private T first;
    private T second;
    public Pair(T first, T second){
        this.first = first;
        this.second = second;
    }
    public void setFirst(T first){
        this.first = first;
    }
    public T getFirst(){
        return first;
    }
    public void setSecond(T second){
        this.second = second;
    }
    public T getSecond(){
        return second;
    }
}
// 第二段代码  时间间隔类
public class DateInterval extends Pair<Date> {     
    public DateInterval(Date first, Date second){
        super(first, second);
    }
    @Override
    public void setSecond(Date second) {
        super.setSecond(second);
    }
    @Override
    public Date getSecond(){
        return super.getSecond();
    }
}

由泛型类的定义可知，Pair 是一个泛型类，因为在类名后面有类型参数；类 DateInterval 后面没有跟类型参数列表，因此该类就是一个 T 被替换为 Date 的实体类，其从 Pair 继承得到的方法列表，与泛型彻底无关。

3. 对泛型类 LinkedList 的类型参数 T 实例化所得到的不同泛型类型的理解

下图中，LinkedList、LinkedList 和 LinkedList 是三种不同的类型，就像 Integer 和 String 一样，是两种互不相同的类型。但是，三者共享同一个 Class 对象。换句话说，三者在运行期的类型是一样的，但在编译期根据类型参数的不同成为截然不同的类型。下面代码可为例证。

public class TestClassTypes {
  public static void main(String[] args) {
  LinkedList<String> proverbs = new LinkedList<>();
  LinkedList<Object> numbers = new LinkedList<>();
   System.out.println("numbers class name: " + numbers.getClass().getName());   // Output: java.util.LinkedList
   System.out.println("proverbs class name: " + proverbs.getClass().getName()); // Output: java.util.LinkedList
   System.out.println("Compare Class objects: " + numbers.getClass().equals(proverbs.getClass()));     // Output:true
   // 由于 LinkedList<String> 与 LinkedList<Object> 在编译期根本就是不同类型，所以下面代码编译不能通过：
   // 类似于：把 Integer 类型实例强制转型为 String实例 赋给 String引用
   proverbs = (LinkedList<String>)numbers;   
   // 每个类都是 Object 的子类
   Object obj = (Object)numbers;
   System.out.println("obj class name " + obj.getClass().getName());  // Output: java.util.LinkedList
   // 会有转型安全的异常
   proverbs = (LinkedList<String>)obj;
   System.out.println("obj in proverbs class name " + obj.getClass().getName()); // Output:java.util.LinkedList
  }
}

4. 泛型与 static

在泛型类中，static 域或方法无法访问泛型类的类型参数(类型实例化所得的所有泛型类型共享同一个Class对象)；若静态方法需要使用泛型能力，就必须使其成为泛型方法（不与泛型类共享类型参数）。

在一个类中，static 域或方法都是该类的 Class 对象的成员，而我们知道泛型所创造出来的所有类型都共享一个 Calss对象， 因此实质上不受泛型参数限制，所以如下代码根本不能通过编译：

public class Test<T> {
    public static T one;           // 编译错误
    public static T show(T one){   // 编译错误
        return null;
    }
}

看下在 Eclipse 中的编译报错提示：

// 不能将一个静态的引用指向一个非静态的类型
Cannot make a static reference to the non-static type T

但是要注意区分下面的一种情况：

public class Test<T> {
    // 这是正确的
    public static <T> T show(T one){
        return null;
    }
}

因为这是一个泛型方法，在泛型方法中使用的 类型参数T 是自己在方法中定义的 T，而不是泛型类中的 T。

5. 限制泛型可用的类型

在定义泛型类时，预设可以使用任何的类型来实例化泛型类中的类型。但是，如果想要限制使用泛型的类型时，即要求只能使用某个特定类型或其子类型才能实例化该类型时，使用 extends 关键字指定这个类型必须是继承或者实现某个接口。**一般地，当没有指定泛型继承的类型或实现的接口时，默认等价于使用 T extends Object，因此，默认情形下任何类型都可以作为参数插入。特别地，为类型参数设定的第一个边界可以是类类型或接口类型，类型参数的第一个边界之后的任意额外边界都只能是接口类型，同时，一般将标记性接口放到靠后位置，这些类型参数之间有 & 相连接。**

publc class MyClass<T extends Number & Serilizable>{
    ...
}

• 在调用泛型方法的时候，可以指定泛型，也可以不指定泛型

在不指定泛型的情况下，泛型变量的类型为该方法中的几种类型的同一个父类的最小级，直到 Object。在指定泛型的时候，该方法中的几种类型必须是该泛型实例类型或者其子类。

// 代码示例
public class Test2{  
    public static void main(String[] args) {  
        /**不指定泛型的时候*/ 
        //这两个参数都是Integer，所以T为Integer类型
        Integer i = Test2.add(1, 2);   
        // 这两个参数一个是Integer，一个是Double，所以取同一父类的最小级，为Number  
        Number f = Test2.add(1, 1.2);  
        // 这两个参数一个是Integer，一个是String，所以取同一父类的最小级，为Object 
        Object o = Test2.add(1, "asd");   
        System.out.println(i.getClass().getName());   // 输出： java.lang.Integer
        System.out.println(f.getClass().getName());   // 输出： java.lang.Double
        System.out.println(o.getClass().getName());   // 输出： java.lang.String
        /**指定泛型的时候*/ 
        // 指定了Integer，所以只能为Integer类型或者其子类
        int a = Test2.<Integer>add(1, 2);   
        // 编译错误，指定了Integer，不能为Double
        int b = Test2.<Integer>add(1, 2.2); 
        // 指定为Number，所以可以为Integer和Double
        Number c = Test2.<Number>add(1, 2.2);    
    }  
    // 这是一个简单的泛型方法  
    public static <T> T add(T x, T y){  
        return y;  
    }  
}

注意，这个例子中的两个输出是 java.lang.Double 和 java.lang.String，而不是 java.lang.Number 和 java.lang.Object：

System.out.println(f.getClass().getName());   // 输出： java.lang.Double
System.out.println(o.getClass().getName());   // 输出： java.lang.String

实际上，这个问题涉及泛型机制和多态两点。在例子中，类型参数 T 被编译器用 Number 替换，这是没问题的，因为无论整形还是浮点型都属于数型，这是由多态机制保证的。但是，无论 x 还是 y，它们本质上还是各自的类型不会发生任何改变。要注意的是，这里的 getClass() 方法返回的变量的实际类型，即运行时类型而非编译时类型，因此返回 y 的类型是double 而非 number。

6. 泛型的兼容性

• 从泛型类型生成的任何类型的引用都能存储到对应的原生类型的变量中

  LinkedList list = new LinkedList();

这样编写代码是合法兼容的，但是，不应该将这作为日常编程习惯的一部分，因为这种实践存在固有的风险：由于 类型安全性检查是针对引用的，所以上述写法和如下写法实质上是一样的：

LinkedList list = new LinkedList();

• 从原生类型生成的引用能存储到任何类型的泛型类型的变量中

  LinkedList list1 = new LinkedList();
  LinkedList list2 = new LinkedList();

这样编写代码是合法兼容的，但是，由于我们可以将一个已经原生的 LinkedList 对象 直接赋值此类引用，虽然在之后在添加元素是会进行类型安全检查，但之前的 LinkedList 对象 所存储的元素可能五花八门，给程序带来隐患。具体请参照下图：

7. primitive 类型不可以作为类型参数（八大类型）

8. 若使用泛型方法可以取代将整个类泛型化，那么就应该使用泛型方法

9. 泛型方法与可变参数列表可以很好的共存

public static <T> void f(T... args){}

三. 通配符及泛型的逆变和协变

1、 通配符

(1).无界通配符

我们知道，通过为泛型类的每个类型形参提供类型实参，可以表达由这个泛型类定义的集合中的特定类型。例如，为了指定存储 String 的 ArrayList，就需要将类型参数设定为 String，所以动态数组类型就是 ArrayList。若不想为泛型类的类型参数提供具体类型，可以将参数设定为 “?”，这就是通配符的作用，通配符类型可以表示任何类或接口类型。

ArrayList<?> list  = new ArrayList<String>();
list  = new ArrayList<Double>();
list.add(e);     // e cannot be resolved to a variable  
System.out.println(list1.size());

list 变量是 ArrayList<?> 类型，所以能将指向任意类型的 ArrayList<> 对象的引用存储在其中。但由于 list 是通配符类型参数的结果，所以存储引用的实际类型并不知道，因而无法使用这个变量调用任何与类型参数有关的方法。特别地，在 Java 集合框架中，对于参数值是未知类型的容器类，只能读取其中元素，不能向其中添加元素。因为其类型未知，所以编译器无法识别添加元素的类型和容器的类型是否兼容，唯一的例外是 null (对 null 而言，无所谓类型)。

(2). 深入理解无界通配符

　　我们有必要对以下三种类型进行区分：

List ：持有任何 Object 类型 的 原生 List，编译器不会对原生类型进行安全检查；

List<?> ：具有某种特定类型 的 非原生List，编译器会进行安全检查；

List