Java 基础 一文搞懂泛型

本文将从以下四个方面来系统的讲解一下泛型，基本上涵盖了泛型的主体内容。

1. 什么是泛型？
2. 为什么要使用泛型？
3. 如何使用泛型？
4. 泛型的特性

1. 什么是泛型？

泛型的英文是Generics，是指在定义方法、接口或类的时候，不预先指定具体的类型，而使用的时候再指定一个类型的一个特性。

写过Java代码的同学应该知道，我们在定义方法、接口或类的时候，都要指定一个具体的类型。比如：

public class test {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

上面代码就定义了字段name的类型为String，方法getName的返回类型为String，这种写法就是预先指定了具体的类型。而泛型就是不预先指定具体的类型。

Java中有一个类型叫ArrayList，相当于一个可变长度的数组。在ArrayList类型中就没有预先指定具体的类型。因为数组可以存放任何类型的数据，如果要预先指定一个数组类型的话，那要满足大家对各种类型的需求，就要写很多类型的ArrayList，要为每个class写一个单独的ArrayList，比如：

• IntegerArrayList

• StringArrayList

• FloatArrayList

• LongArrayList

• ...

这显然不太现实，因为class有上千种，还有自己定义的class。那么在ArrayList中预先指定具体的类型就无法满足需求。这个时候就需要使用泛型，即不指定存储数据的具体的类型，这个类型由使用者决定。

为了解决类型的问题，我们必须把ArrayList变成一种模板：ArrayList，代码如下：

public class ArrayList {
    private T[] array;
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}

T可以是任何class，这样一来，我们就实现了：编写一次模版，可以创建任意类型的ArrayList：

// 创建可以存储String的ArrayList:
ArrayList strList = new ArrayList();
// 创建可以存储Float的ArrayList:
ArrayList floatList = new ArrayList();
// 创建可以存储Person的ArrayList:
ArrayList personList = new ArrayList();

因此，泛型也可以说是定义一种模板，例如ArrayList，然后在代码中为用到的类创建对应的ArrayList<类型>。（泛型是指在定义方法、接口或类的时候，不预先指定具体的类型，而使用的时候再指定一个类型的一个特性。）后面这种定义可能会更好理解其本质。

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

2. 为什么要使用泛型？

参考自：Oracle 泛型文档

与非泛型的代码相比，使用泛型的代码具有很多优点：

1. 在编译时会有更强的类型检查

   Java编译器对泛型代码进行强类型检查，如果代码违反类型安全，则会发出错误。修复编译时的错误比修复运行时的错误会更加简单，运行时的错误会更难找到。

   说人话就是，使用泛型时，编译器会对输入的类型的进行检查，类型与声明的类型不一致时就会报错。而不使用泛型，编译器可能就检测不到这个类型错误，就会在运行的时候报错。

2. 消除类型转换

   下面的代码是没有使用泛型的情况，这时候需要对类型进行转换

   List list = new ArrayList();
   list.add("hello");
   String s = (String) list.get(0);
   

   使用泛型，就不需要对类型进行转换

   List list = new ArrayList();
   list.add("hello");
   String s = list.get(0);   // no cast
   

3. 可以实现更通用的算法

   通过使用泛型，程序员可以对不同类型的集合进行自定义操作以实现通用算法，并且代码类型会更加安全、代码更易读

3. 如何使用泛型？

还是以ArrayList为例，如果不定义泛型类型时，泛型类型此时就是Object：

// 编译器警告:
List list = new ArrayList();
list.add("Hello");
list.add("World");
String first = (String) list.get(0);
String second = (String) list.get(1);

此时，只能把当作Object使用，没有发挥泛型的优势。

当我们定义泛型类型后，List的泛型接口变为强类型List：

// 无编译器警告:
List list = new ArrayList();
list.add("Hello");
list.add("World");
// 无强制转型:
String first = list.get(0);
String second = list.get(1);

编译器看到泛型类型List就可以自动推断出后面的ArrayList的泛型类型必须是ArrayList，因此，可以把代码简写为：

// 可以省略后面的Number，编译器可以自动推断泛型类型：
List list = new ArrayList<>();

3.1 泛型类

泛型类的语法形式：

class name { /* ... */ }

泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。由尖括号（<>）分隔的类型参数部分跟在类名后面。它指定类型参数（也称为类型变量）T1，T2，...和 Tn。

一般将泛型中的类名称为原型，而将 <> 指定的参数称为类型参数。

在泛型出现之前，一个类要想处理所有类型的数据，只能使用Object做数据转换。实例如下：

public class Info {
	private Object value;

	public Object getValue() {
		return value;
	}

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

使用泛型之后，其实就是将Object换成T，并声明：

public class Info {
	private T value;
    
    public T getValue() {
        return value;
    }
    
    public void setValue(T value) {
        this.value = value;
    }
}

在上面的例子中，在初始化一个泛型类时，使用 <> 指定了内部具体类型，在编译时就会根据这个类型做强类型检查。

实际上，不使用 <> 指定内部具体类型，语法上也是支持的（不推荐这么做）,这样的调用就失去泛型类型的优势。如下所示：

public static void main(String[] args) {
    Info info = new Info();
    info.setValue(10);
    System.out.println(info.getValue());
    info.setValue("abc");
    System.out.println(info.getValue());
}

上面是单个类型参数的泛型类。

下面我们看一下多个类型参数的泛型类该如何编写。

例如，我们定义Pair不总是存储两个类型一样的对象，就可以使用类型：

public class Pair {
    private T first;
    private K last;
    
    public Pair(T first, K last) {
        this.first = first;
        this.last = last;
    }
    
    public T getFirst() { 
    	return first;
    }
    
    public K getLast() { 
    	return last;
    }
}

使用的时候，需要指出两种类型：

Pair p = new Pair<>("test", 123);

Java标准库的Map就是使用两种泛型类型的例子。它对Key使用一种类型，对Value使用另一种类型。

小结

编写泛型时，需要定义泛型类型；

泛型可以同时定义多种类型，例如Map。

3.2 泛型接口

接口也可以声明泛型。

泛型接口语法形式：

public interface Content {
    T text();
}

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

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

  预先声明继承的具体类型的接口类，下面就是继承的Integer类型的接口类。

  public class IntContent implements Content {
      private int text;
  
      public IntContent(int text) {
          this.text = text;
      }
  
      @Override
      public Integer text() { 
          return text; 
      }
  }
  

  因为子类并没有泛型类型，所以正常使用就行。

  InContent ic = new IntContent(10);
  

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

  public class GenericsContent implements Content {
      private T text;
  
      public GenericsContent(T text) {
          this.text = text;
      }
  
      @Override
      public T text() { 
          return text; 
      }
  }
  

  此时子类也使用了泛型类型，就需要指定具体类型

  Content gc = new GenericsContent<>("ABC");
  

3.3 泛型方法

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

泛型方法语法形式如下：

public  T func(T obj) {}

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

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

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

编译器会认为：调用泛型方法后，其返回值被赋给一个 Object 类型的变量。

public class GenericsMethodDemo01 {
    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 GenericVarargsMethodDemo {
    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]

4. 泛型的特性

4.1 类型擦除（Type Erasure）

Java 语言引入泛型是为了在编译时提供更严格的类型检查，并支持泛型编程。不同于 C++ 的模板机制，Java 泛型是使用类型擦除来实现的，使用泛型时，任何具体的类型信息都被擦除了。

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

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

Java 泛型的实现方式不太优雅，但这是因为泛型是在 JDK5 时引入的，为了兼容老代码，必须在设计上做一定的折中。

简单来说类型擦除是指，虚拟机对泛型其实一无所知，所有的工作都是编译器做的。

例如，我们编写了一个泛型类Pair，这是编译器看到的代码：

public class Pair {
    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;
    }
}

而虚拟机根本不知道泛型。这是虚拟机执行的代码：

public class Pair {
    private Object first;
    private Object last;
    public Pair(Object first, Object last) {
        this.first = first;
        this.last = last;
    }
    public Object getFirst() {
        return first;
    }
    public Object getLast() {
        return last;
    }
}

因此，Java使用类型擦拭实现泛型，导致了：

• 编译器把类型视为Object；
• 编译器根据实现安全的强制转型。

因此，Java使用擦拭法实现泛型，导致了：

• 编译器把类型视为Object；
• 编译器根据实现安全的强制转型。

使用泛型的时候，我们编写的代码也是编译器看到的代码：

Pair p = new Pair<>("Hello", "world");
String first = p.getFirst();
String last = p.getLast();

而虚拟机执行的代码并没有泛型：

Pair p = new Pair("Hello", "world");
String first = (String) p.getFirst();
String last = (String) p.getLast();

所以，Java的泛型是由编译器在编译时实行的，编译器内部永远把所有类型T视为Object处理，但是，在需要转型的时候，编译器会根据T的类型自动为我们实行安全地强制转型。

泛型的局限

了解了Java泛型的实现方式——类型擦除，我们就知道了Java泛型的局限：

局限一：不能是基本类型，例如int，因为实际类型是Object，Object类型无法持有基本类型：

Pair p = new Pair<>(1, 2); // compile error!

局限二：无法取得带泛型的Class。观察以下代码：

public class test {
    public static void main(String[] args) {
        List