流华追梦^_^

Java 泛型机型详解

目录

一. 前言

二. 为什么要引入泛型

三. 泛型的基本使用

3.1. 泛型类

3.2. 泛型接口

3.3. 泛型方法

3.4. 泛型的上下限

3.5. 泛型数组

3.6. 小结

四. 深入理解泛型

4.1. 如何理解 Java 中的泛型是伪泛型？泛型中类型擦除

4.2. 那么如何进行擦除的呢？

4.3. 如何证明类型的擦除呢？

4.4. 如何理解类型擦除后保留的原始类型？

4.5. 如何理解泛型的编译期检查？

4.6. 如何理解泛型的多态？泛型的桥接方法

4.7. 如何理解基本类型不能作为泛型类型？

4.8. 如何理解泛型类型不能实例化？

4.9. 泛型数组：能不能采用具体的泛型类型进行初始化？

4.10. 泛型数组：如何正确的初始化泛型数组实例？

4.11. 如何理解泛型类中的静态方法和静态变量？

4.12. 如何理解异常中使用泛型？

4.12.1. 不能抛出也不能捕获泛型类的对象

4.12.2. 不能在 catch 子句中使用泛型变量

4.13. 如何获取泛型的参数类型？

五. 总结

一. 前言

Java 泛型这个特性是从 JDK 1.5 才开始加入的，因此为了兼容之前的版本，Java 泛型的实现采取了“伪泛型”的策略，即 Java 在语法上支持泛型，但是在编译阶段会进行所谓的“类型擦除”（Type Erasure），将所有的泛型表示（尖括号中的内容）都替换为具体的类型（其对应的原生态类型），就像完全没有泛型一样。

二. 为什么要引入泛型

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

引入泛型的意义在于：适用于多种数据类型执行相同的代码（代码复用）。

我们通过一个例子来阐述，先看下下面的代码：

private static int add(int a, int b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}

private static float add(float a, float b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}

private static double add(double a, double b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}

如果没有泛型，要实现不同类型的加法，每种类型都需要重载一个 add 方法；通过泛型，我们可以复用为一个方法：

private static  double add(T a, T b) {
    System.out.println(a + "+" + b + "=" + (a.doubleValue() + b.doubleValue()));
    return a.doubleValue() + b.doubleValue();
}

泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型）。看下这个例子：

List list = new ArrayList();
list.add("流华追梦");
list.add(100d);
list.add(new Person());

我们在使用上述 list 时，list 中的元素都是 Object 类型（无法约束其中的类型），所以在取出集合元素时需要人为的强制类型转化到具体的目标类型，且很容易出现 java.lang.ClassCastException异常。

引入泛型，它将提供类型的约束，提供编译前的检查：

List list = new ArrayList<>();

// list中只能放String, 不能放其它类型的元素

三. 泛型的基本使用

3.1. 泛型类

从一个简单的泛型类看起：

class Point {         // 此处可以随便写标识符号，T是type的简称  
    private T var;         // var的类型由T指定，即：由外部指定  

    public T getVar() {      // 返回值的类型由外部决定  
        return var;  
    }

    public void setVar(T var) {  // 设置的类型也由外部决定  
        this.var = var ;  
    }  
}

public class GenericsDemo01 {
    public static void main(String[] args) {  
        Point p = new Point<>();             // 里面的var类型为String类型  
        p.setVar("it");                              // 设置字符串  
        System.out.println(p.getVar().length()) ;   // 取得字符串的长度  
    }  
}

多元泛型：

class Notepad {       // 此处指定了两个泛型类型  
    private K key;     // 此变量的类型由外部决定  
    private V value;   // 此变量的类型由外部决定  
   
    public K getKey() {  
        return this.key;  
    }  

    public V getValue() {  
        return this.value;  
    }  

    public void setKey(K key) {  
        this.key = key;  
    }  

    public void setValue(V value) {  
        this.value = value;  
    }  
} 

public class GenericsDemo01 {  
    public static void main(String[] args) {
        Notepad t = null ;        // 定义两个泛型类型的对象  
        t = new Notepad<>() ;        // 里面的key为String，value为Integer  
        t.setKey("流华追梦");            // 设置第一个内容  
        t.setValue(20);              // 设置第二个内容  
        System.out.print("姓名；" + t.getKey());      // 取得信息  
        System.out.print("，年龄；" + t.getValue());       // 取得信息
    }  
}

3.2. 泛型接口

简单的泛型接口：

interface Info {        // 在接口上定义泛型  
    public T getVar(); // 定义抽象方法，抽象方法的返回值就是泛型类型  
}

class InfoImpl implements Info {   // 定义泛型接口的子类  
    private T var;             // 定义属性
	
    public InfoImpl(T var) {     // 通过构造方法设置属性内容  
        this.setVar(var);    
    }
	
    public void setVar(T var) {  
        this.var = var;  
    }
	
    public T getVar() {
        return this.var;  
    }
}

public class GenericsDemo01 {  
    public static void main(String[] arsg) {  
        Info i = null;        // 声明接口对象  
        i = new InfoImpl<>("流华追梦");  // 通过子类实例化对象  
        System.out.println("内容：" + i.getVar());  
    }
}

3.3. 泛型方法

泛型方法，是在调用方法的时候指明泛型的具体类型。

1. 定义泛型方法语法格式：

2. 调用泛型方法语法格式：

说明一下，定义泛型方法时，必须在返回值前边加一个，来声明这是一个泛型方法，持有一个泛型 T，然后才可以用泛型 T 作为方法的返回值。

Class 的作用就是指明泛型的具体类型，而 Class 类型的变量 c，可以用来创建泛型类的对象。

为什么要用变量 c 来创建对象呢？既然是泛型方法，就代表着我们不知道具体的类型是什么，也不知道构造方法如何，因此没有办法去 new 一个对象，但可以利用变量 c 的 newInstance 方法去创建对象，也就是利用反射创建对象。

泛型方法要求的参数是 Class 类型，而 Class.forName() 方法的返回值也是 Class，因此可以用 Class.forName() 作为参数。其中，forName() 方法中的参数是何种类型，返回的 Class 就是何种类型。在本例中，forName() 方法中传入的是 User 类的完整路径，那么返回的就是 Class 类型的对象，因而调用泛型方法时，变量 c 的类型就是 Class，因此泛型方法中的泛型 T 就被指明为 User，所以变量 obj 的类型为 User。

当然，泛型方法不是仅仅可以有一个参数 Class，可以根据需要添加其他参数。

为什么要使用泛型方法呢？因为泛型类要在实例化的时候就指明类型，如果想换一种类型，不得不重新 new 一次，可能不够灵活；而泛型方法可以在调用的时候指明类型，更加灵活。

3.4. 泛型的上下限

先看下如下的代码，很明显是会报错的：

class A {}

class B extends A {}

// 如下两个方法不会报错
public static void funA(A a) {
    // ...          
}

public static void funB(B b) {
    funA(b);
    // ...             
}

// 如下funD方法会报错
public static void funC(List listA) {
    // ...          
}

public static void funD(List listB) {
    funC(listB); // Unresolved compilation problem: The method doPrint(List) in the type test is not applicable for the arguments (List)
    // ...             
}

那么如何解决呢？为了解决泛型中隐含的转换问题，Java 泛型加入了类型参数的上下边界机制。表示该类型参数可以是 A（上边界）或者 A 的子类类型。编译时擦除掉类型 A，即用 A 类型代替类型参数。这种方法可以解决开始遇到的问题，编译器知道类型参数的范围，如果传入的实例类型 B 是在这个范围内的话允许转换，这时只要一次类型转换就可以了，运行时会把对象当做 A 的实例看待。

public static void funC(List listA) { // ... } public static void funD(List listB) { funC(listB); // OK // ... }

在使用泛型的时候，我们可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。

上限：

class Info { // 此处泛型只能是数字类型 private T var; // 定义泛型变量 public void setVar(T var) { this.var = var; } public T getVar() { return this.var; } public String toString() { // 直接打印 return this.var.toString(); } } public class demo1 { public static void main(String[] args) { Info i1 = new Info<>(); // 声明Integer的泛型对象 } }

下限：

class Info { private T var; // 定义泛型变量 public void setVar(T var) { this.var = var; } public T getVar() { return this.var; } public String toString() { // 直接打印 return this.var.toString(); } } public class GenericsDemo01 { public static void main(String[] args) { Info i1 = new Info<>(); // 声明String的泛型对象 Info