从一知半解到揭晓Java高级语法—泛型

前言

泛型是Java基础知识的重点，虽然我们在初学Java的时候，都学过泛型，觉得自己掌握对于Java泛型的使用（全是错觉），往后的日子，当我们深入去阅读一些框架源码，你就发现了，自己会的只是简单的使用，却看不懂别人的泛型代码是怎么写的，还可以这样，没错，别人写出来的代码那叫艺术，而我......

探讨

Java语言为什么存在着泛型，而像一些动态语言Python,JavaScipt却没有泛型的概念？

原因是，像Java，C#这样的静态编译型的语言，它们在传递参数的时候，参数的类型，必须是明确的，看一个例子，简单编写一个存放int类型的栈—StackInt,代码如下：

public class StackInt {

    private int maxSize;
    private int[] items;
    private int top;

    public StackInt(int maxSize){
        this.maxSize = maxSize;
        this.items = new int[maxSize];
        this.top = -1;
    }

    public boolean isFull(){
        return this.top == this.maxSize-1;
    }

    public boolean isNull(){
        return this.top <= -1;
    }

    public boolean push(int value){
        if(this.isFull()){
            return false;
        }
        this.items[++this.top] = value;
        return true;
    }

    public int pop(){
        if(this.isNull()){
            throw new RuntimeException("当前栈中无数据");
        }
        int value = this.items[top];
        --top;
        return value;
    }
}

在这里使用构造函数初始化一个StackInt对象时，可以传入String字符串吗？很明显是不行的，我们要求的是int类型，传入字符串String类型，这样在语法检查阶段时会报错的，像Java这样的静态编译型的语言，参数的类型要求是明确的

泛型解决了什么问题？

参数不安全：引入泛型，能够在编译阶段找出代码的问题，而不是在运行阶段

泛型要求在声明时指定实际数据类型，Java 编译器在编译时会对泛型代码做强类型检查，并在代码违反类型安全时发出告警。早发现，早治理，把隐患扼杀于摇篮，在编译时发现并修复错误所付出的代价远比在运行时小。

避免类型转换：

未使用泛型：

List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);    //需要在取出Value的时候进行强制转换

使用泛型：

List list = new ArrayList();
list.add("hello");
String s = list.get(0);   //不需要强制转换

重复编码：：通过使用泛型，可以实现通用编码，可以处理不同类型的集合，并且类型安全且易于阅读。像上面的StackInt类，我们不能针对每个类型去编写对应类型的栈，那样太麻烦了，而泛型的出现就很好的解决了这点

扩展

在上面的StackInt类有一些不好的地方，那就是太具体了，不够抽象，不够抽象，那么它的复用性也是不高的，例如，在另外的场景下，我需要的是往栈里存String类型的字符串，或者是其他类型，那么StackInt类就做不到了，那么有什么方法能够做到呢？再写一个StackString类，不可能，那样不得累死。那就只有引入基类Object了，我们改进一下代码：

public class StackObject {

    private int maxSize;
    private Object[] items;
    private int top;

    public StackObject(int maxSize){
        this.maxSize = maxSize;
        this.items = new Object[maxSize];
        this.top = -1;
    }

    public boolean isFull(){
        return this.top == this.maxSize-1;
    }

    public boolean isNull(){
        return this.top <= -1;
    }

    public boolean push(Object value){
        if(this.isFull()){
            return false;
        }
        this.items[++this.top] = value;
        return true;
    }

    public Object pop(){
        if(this.isNull()){
            throw new RuntimeException("当前栈中无数据");
        }
        Object value = this.items[top];
        --top;
        return value;
    }
}

使用StackObject可以存储任意类型的数据，那么这样做，又有什么优点和缺点呢？

优点：StackObject类变得相对抽象了，我们可以往里面存储任何类型的数据，这样就避免了写一些重复代码

缺点：

1、用Object表示的对象是比较抽象的，它失去了类型的特点，那么我们在做一些运算的时候，可能会频繁的拆箱装箱的过程

看上面的例图，我们理解的认为存放了两个数值，12345和54321,将两个进行相加，这是很常见的操作，但是报错了，编译器给我们的提示是，+操作运算不能用于两个Object类型，那么只能对其进行类型转换，这也是我们上面说到的泛型能解决的问题，我们需要这样做，int sum = (int)val1 + (int)val2;,同时在涉及拆箱装箱时，是有一定性能的损耗的，关于拆箱装箱在这里不作描述，可以参考我写过的随笔—— 深入理解Java之装箱与拆箱

2、对于我们push进去的值，我们在取出的时候，容易忘记类型转换，或者不记得它的类型，类型转换错误，这在后面的一些业务可能埋下祸根，例如下面这个场景：直到运行时错误才暴露出来，这是不安全的，也是违反软件开发原则的，应该尽早的在编译阶段就发现问题，解决问题

3、使用Object太过于模糊了，没有具体类型的意义

最好不要用到Object,因为Object是一切类型的基类，也就是说他把一些类型的特点给抹除了，比如上面存的数字，对于数字来说，加法运算就是它的一个特点，但是用了Object，它就失去了这一特点，失去类型特有的行为

引入泛型

什么是泛型？

泛型：是被参数化的类或接口，是对类型的约定

泛型类

class name { /* ... */ }

一般将泛型中的类名称为原型，而将 <> 指定的参数称为类型参数，<> 相当于类型的约定，T就是类型，相当于一个占位符，由我们在调用时指定

使用泛型改进一下上面StackObject类，但是，数组和泛型不能很好地结合。你不能实例化具有参数化类型的数组，例如下面的代码是不合格的：

public StackT(int maxSize){
    this.maxSize = maxSize;
    this.items = new T[maxSize];
    this.top = -1;
}

Java 中不允许直接创建泛型数组，这是因为相比于C++,C#的语法，Java泛型其实是伪泛型，这点在后面会说到，但是，可以通过创建一个类型擦除的数组，然后转型的方式来创建泛型数组。

private int maxSize;
private T[] items;     
private int top;

public StackT(int maxSize){
    this.maxSize = maxSize;
    this.items = (T[]) new Object[maxSize];
    this.top = -1;
}

实际上，真的需要存储泛型，还是使用容器更合适，回到原来的代码上，需要知道的是，泛型类型不能是基本类型的，需要是包装类

上面说到了Java 中不允许直接创建泛型数组，事实上，Java中的泛型我们是很难通new的方式去实例化对象，不仅仅是实例化对象，甚至是获取T的真实类型也是很难的，当然通过反射的机制还是可以获取到的，Java获取真实类型的方式有 3 种，分别是：

1、类名.class

2、对象.getClass

3、class.forName("全限定类名")

但是，在这里，1和2的方式都是做不到的，虽然我们在外边明确的传入了Integer类型，new StackT(3);但是在StackT

类，使用T.class还是获取不到真实类型的，第 2 种方式的话，并没有传入对象，前面也说到是没有办法new方式实例化的，而通过反射机制是可以做到的，这里不作演示，需要了解的话可以参考 —— Java如何获得泛型类的真实类型、 Java通过反射获取泛型的类型

但是在C#中的泛型以及C++的模板，这是很容易做到的，所以说Java的泛型是伪泛型，Java并不是做不到像C#一样，而是为了迁就老的JDK语法所作出的妥协，至于上面为什么做不到这样，这就要说到泛型的类型擦除了。

再说类型擦除之前，先说一下泛型接口，和泛型方法吧

泛型接口

接口也可以声明泛型，泛型接口语法形式：

public interface Content {
    T text();
}

泛型接口有两种实现方式：

• 实现接口的子类明确声明泛型类型

public class ContentImpl implements Content {
    private int text;

    public ContentImpl(int text) {
        this.text = text;
    }

    public static void main(String[] args) {
        ContentImpl one = new ContentImpl(10);
        System.out.print(one.text());
    }
}
// Output:
// 10

• 实现接口的子类不明确声明泛型类型

public class ContentImpl implements Content {
    private T text;

    public ContentImpl(T text) {
        this.text = text;
    }

    @Override
    public T text() { return text; }

    public static void main(String[] args) {
        ContentImpl two = new ContentImpl<>("ABC");
        System.out.print(two.text());
    }
}
// Output:
// ABC

泛型方法

泛型方法是引入其自己的类型参数的方法。泛型方法可以是普通方法、静态方法以及构造方法。

泛型方法语法形式如下：

public  T func(T obj) {}

是否拥有泛型方法，与其所在的类是否是泛型没有关系。

泛型方法的语法包括一个类型参数列表，在尖括号内，它出现在方法的返回类型之前。对于静态泛型方法，类型参数部分必须出现在方法的返回类型之前。类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际类型参数的占位符。

使用泛型方法的时候，通常不必指明类型参数，因为编译器会为我们找出具体的类型。这称为类型参数推断（type argument inference）。类型推断只对赋值操作有效，其他时候并不起作用。如果将一个泛型方法调用的结果作为参数，传递给另一个方法，这时编译器并不会执行推断。编译器会认为：调用泛型方法后，其返回值被赋给一个 Object 类型的变量。

public class GenericsMethod {
    public static  void printClass(T obj) {
        System.out.println(obj.getClass().toString());
    }

    public static void main(String[] args) {
        printClass("abc");
        printClass(10);
    }
}
// Output:
// class java.lang.String
// class java.lang.Integer

泛型方法中也可以使用可变参数列表

public class GenericVarargsMethod {
    public static  List makeList(T... args) {
        List result = new ArrayList();
        Collections.addAll(result, args);
        return result;
    }

    public static void main(String[] args) {
        List ls = makeList("A");
        System.out.println(ls);
        ls = makeList("A", "B", "C");
        System.out.println(ls);
    }
}
// Output:
// [A]
// [A, B, C]

类型擦除

事实上，Java的运行大致可以分为两个阶段，编译阶段，运行阶段

那么对于Java泛型来说，当编译阶段过后，泛型 T 是已经被擦除了，所以在运行阶段，它已经丢失了 T 的具体信息，而我们去实例化一个对象的时候，比如T c = new T();,它的发生时机是在运行阶段，而在运行阶段，你要new T(),就需要知道 T 的具体类型，实际上这时候 T是被替换成Integer了，而JVM是不知道T的类型的，所以是没有办法实例化的。

那么，类型擦除做了什么呢？它做了以下工作：

• 把泛型中的所有类型参数替换为 Object，如果指定类型边界，则使用类型边界来替换。因此，生成的字节码仅包含普通的类，接口和方法。
• 擦除出现的类型声明，即去掉 <> 的内容。比如 T get() 方法声明就变成了 Object get() ；List 就变成了 List。如有必要，插入类型转换以保持类型安全。
• 生成桥接方法以保留扩展泛型类型中的多态性。类型擦除确保不为参数化类型创建新类；因此，泛型不会产生运行时开销。

让我们来看一个示例：

import java.util.*;

public class ErasedTypeEquivalence {

    public static void main(String[] args) {
        Class c1 = new ArrayList().getClass();
        Class c2 = new ArrayList().getClass();
        System.out.println(c1 == c2);
    }

}
/* Output:
true
*/

ArrayList 和 ArrayList 应该是不同的类型。不同的类型会有不同的行为。例如，如果尝试向 ArrayList 中放入一个 Integer，所得到的行为（失败）和 向 ArrayList 中放入一个 Integer 所得到的行为（成功）完全不同。但是结果输出的是true,这意味着使用泛型时，任何具体的类型信息都被擦除了，ArrayList