一、泛型的概念

泛型是 Java SE5 出现的新特性，泛型的本质是类型参数化或参数化类型，在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型。

二、泛型的意义

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

Java 在引入泛型之前，表示可变对象，通常使用 Object 来实现，但是在进行类型强制转换时存在安全风险。有了泛型后：

  • 编译期间确定类型，保证类型安全，放的是什么，取的也是什么，不用担心抛出 ClassCastException 异常。
  • 提升可读性，从编码阶段就显式地知道泛型集合、泛型方法等处理的对象类型是什么。
  • 泛型合并了同类型的处理代码提高代码的重用率，增加程序的通用灵活性。

举个例子：

  1. public static void method1() {
  2.     List list = new ArrayList();
  3.     List.add(22);
  4.     List.add("hncboy");
  5.     List.add(new Object());
  7.     for (Object o : list) {
  8.         System.out.println(o.getClass());
  9.     }
  10. }

未使用泛型前，我们对集合可以进行任意类型的 add 操作，遍历结果都被转换成 Object 类型，因为不确定集合里存放的具体类型，输出结果如下所示。

  1. class java.lang.Integer
  2. class java.lang.String
  3. class java.lang.Object

采用泛型之后，创建集合对象可以明确的指定类型，在编译期间就确定了该集合存储的类型，存储其他类型的对象编译器会报错。这时遍历集合就可以直接采用明确的 String 类型输出。

  1. public static void method2() {
  2.     List<String> list = new ArrayList();
  3.     list.add("22");
  4.     list.add("hncboy");
  5.     //list.add(new Object()); 报错
  7.     for (String s : arrayList) {
  8.         System.out.println(s);
  9.     }
  10. }

三、泛型的表示

泛型可以定义在类、接口、方法中，分别表示为泛型类、泛型接口、泛型方法。泛型的使用需要先声明，声明通过<符号>的方式，符号可以任意，编译器通过识别尖括号和尖括号内的字母来解析泛型。泛型的类型只能为类，不能为基本数据类型。尖括号的位置也是固定的，只能在类名之后或方法返回值之前。

一般泛型有约定的符号：E 代表 Element， 通常在集合中使用；T 代表 Type，通常用于表示类；K 代表 Key，V 代表 Value， 通常用于键值对的表示；? 代表泛型通配符。

泛型的表达式有如下几种：

  • 普通符号
  • 无边界通配符 <?>
  • 上界通配符 <? extends E> 类是 E
  • 下界通配符 <? super E> 是 E 的父类

四、泛型的使用

4.1 泛型类

将泛型定义在类名后，使得用户在使用该类时，根据不同情况传入不同类型。在类上定义的泛型，在实例方法中可以直接使用，不需要定义，但是静态方法上的泛型需要在静态方法上声明，不能直接使用。举个例子：

  1. public class Test<T> {
  3.     private T data;
  5.     public T getData() {
  6.         return data;
  7.     }
  9.     /** 这种写法是错误的，提示 T 未定义 */
  10.     /*public static T get() {
  11.         return null;
  12.     }*/
  13.     /** 正确写法，该方法上的 T 和类上的 T 虽然一样，但是是两个指代，可以完全相同，互不影响 */
  14.     public static <T> T get() {
  15.         return null;
  16.     }
  18.     public void setData(T data) {
  19.         this.data = data;
  20.     }
  21. }

4.2 泛型方法

泛型方法，是在调用方法时指明的具体的泛型类型。虽然类上定义的泛型，实例方法中可以直接使用，但是该方法不属于泛型方法。举个例子：get 方法为泛型方法，而且该程序能编译通过运行，因为尖括号里的每个元素都指代一种未知类型，可以为任何符号，尖括号里的 String 并非 java.lang.String 类型，而是作为泛型标识 ，传入的 first 为 Integer 类型，所以该 String 标识符也指代 Integer 类型，返回值自然也是 Integer 类型。不过，应该也不会用这种泛型符号定义在实际情况中。

  1. public class Test {
  3.     public static <String, T, Hncboy> String get(String string, Hncboy hncboy) {
  4.         return string;
  5.     }
  7.     public static void main(String[] args) {
  8.         Integer first = 666;
  9.         Double second = 888.0;
  10.         Integer result = get(first, second);
  11.         System.out.println(result);
  12.     }
  13. }

4.3 泛型通配符

? 为泛型非限定通配符，表示类型未知，不用声明，可以匹配任意的类。该通配符只能读，不能写，且不对返回值进行操作。也可以将非限定通配符出现的地方用普通泛型标识，不过使用通配符更简洁。举个例子：

test1() 是通过通配符来输出集合的每一个元素的，test2() 和 test1() 的作用一样，只不过将通配符用来代替了；test3() 用来演示集合在通配符的情况下写操作，发现编译器报错，int 和 String 都不属于 ? 类型，当然放不进集合，因为所有类都有 null 元素，所以可以放进集合。比如主函数传的是 List，而想要在集合里添加一个 String，这是不可能的；test4() 的写法也是错的，? 是不确定，返回值返回不了；test5() 的用法使用来比较 List 和 List<?> 的，在主函数里调用 test5(list) 报错的，显示 java: 不兼容的类型: java.util.List无法转换为java.util.List，因为 List 不是 List 的子类。

  1. public class Test {
  3.     public static void test1(List<?> list) {
  4.         for (int i = 0; i < list.size(); i++) {
  5.             System.out.println(list.get(i));
  6.         }
  7.     }
  9.     public static <T> void test2(List<T> list) {
  10.         for (int i = 0; i < list.size(); i++) {
  11.             System.out.println(list.get(i));
  12.         }
  13.     }
  15.     public static void test3(List<?> list) {
  16.         //list.add(1); capture of ?
  17.         //list.add("1"); capture of ?
  18.         list.add(null);
  19.     }
  21.     /*public static ? test4(List<?> list) {
  22.         return null;
  23.     }*/
  25.     public static void test5(List<Object> list) {
  26.         for (int i = 0; i < list.size(); i++) {
  27.             System.out.println(list.get(i));
  28.         }
  29.     }
  31.     public static void main(String[] args) {
  32.         List<Integer> list = new ArrayList<>();
  33.         list.add(1);
  34.         list.add(2);
  35.         list.add(3);
  36.         test1(list);
  37.         test2(list);
  38.         //test5(list);
  39.     }
  40. }

通过使用泛型通配符可以实现泛型的上下边界 <? extend T> 和 <? super T>，下面将使用 Number 类以及该类的子类来演示这两种上下型边界，Number 类的关系图如下。

😀 什么是泛型 - 图1

<? extends Number> 表示类型为 Number 或 Number 的子类，<? super Integer> 表示类型为 Integer 或 Integer 的父类，举个例子，method1 方法测试是上边界 Number，由于 arrayList1 和 arrayList2 的泛型都为 Number 或其子类，所以可以插入成功，而 arrayList3 的类型 String 和 Number 无关，因此编译报错。method2 方法测试的是下边界 Integer，由于 arrayList4，arrayList5 和 arrayList7 种的类型 Integer、Object 和 Number 都为 Integer 的父类，所以插入成功，而 arrayList7 的类型 Double，因此插入失败。

  1. public class Generic {
  3.     public static void main(String[] args) {
  4.          ArrayList<Integer> arrayList1 = new ArrayList<>();
  5.             ArrayList<Number> arrayList2 = new ArrayList<>();
  6.             ArrayList<String> arrayList3 = new ArrayList<>();
  7.             method1(arrayList1);
  8.             method1(arrayList2);
  9.          //method1(arrayList3);
  11.         ArrayList<Integer> arrayList4 = new ArrayList<>();
  12.          ArrayList<Object> arrayList5 = new ArrayList<>();
  13.          ArrayList<Number> arrayList6 = new ArrayList<>();
  14.          ArrayList<Double> arrayList7 = new ArrayList<>();
  15.          method2(arrayList4);
  16.          method2(arrayList5);
  17.          method2(arrayList6);
  18.          //method2(arrayList7)
  19.     }
  21.     public static void method1(ArrayList<? extends Number> arrayList) {
  22.     }
  24.     public static void method2(ArrayList<? super Integer> arrayList) {
  25.     }
  26. }

4.4 泛型接口

泛型接口就是在接口上定义的泛型，当一个类型未确定的类实现接口时，需要声明该类型。举个例子：

  1. public interface CalcGeneric<T> {
  2.     T add(T num1, T num2);
  3. }
  5. public class CalculatorGeneric<T> implements CalcGeneric<T> {
  7.     @Override
  8.     public T add(T num1, T num2) {
  9.         return null;
  10.     }
  11. }

4.5 泛型数组

数组是支持协变的，什么是数组的协变呢？举个例子：这段代码中，数组支持以 1 的方式定义数组，因为 Integer 是 Number 的子类，一个 Integer 对象也是一个 Number 对象，所以一个 Integer 的数组也是一个 Number 的数组，这就是数组的协变。虽然这种写法编译时能通过，但是数组实际上存储的是 Integer 对象，如果加入 Double 对象，那么在运行时就会抛出 ArrayStoreException 异常，该种设计存在缺陷。3 方式所示的定义数组方式编译错误，4 所指示的代码才是正确的。泛型是不变的，没有内建的协变类型，使用泛型的时候，类型信息在编译期会被类型擦除，所以泛型将这种错误检测移到了编译器。泛型的设计目的之一就是保证了类型安全，让这种运行时期的错误在编译期就能发现，所以泛型是不支持协变的，如 5 所示的该行代码会有编译错误，

  1. public class Test {
  3.     public static void main(String[] args) {
  4.         Number[] numbers = new Integer[10]; // 1
  5.         // java.lang.ArrayStoreException: java.lang.Double
  6.         numbers[0] = new Double(1); // 2
  7.         //List<String>[] list = new ArrayList<String>[10]; // 3
  8.         List<String>[] list2 = new ArrayList[10]; // 4
  9.         //List<Number> list3 = new ArrayList<Integer>(); // 5
  10.     }
  11. }

4.6 泛型擦除

在泛型内部，无法获得任何有关泛型参数类型的信息，泛型只在编译阶段有效，泛型类型在逻辑上可看成是多个不同的类型，但是其实质都是同一个类型。因为泛型是在JDK5之后才出现的，需要处理 JDK5之前的非泛型类库。擦除的核心动机是它使得泛化的客户端可以用非泛化的类库实现，反之亦然，这经常被称为”迁移兼容性”。

代价：泛型不能用于显式地引用运行时类型地操作之中，例如转型、instanceof 操作和 new 表达式，因为所有关于参数地类型信息都丢失了。无论何时，当你在编写这个类的代码的时候，提醒自己，他只是个Object。catch 语句不能捕获泛型类型的异常。

举个例子：这串代码的运行输出是，因此可见泛型在运行期间对类型进行了擦除。

  1. class java.util.ArrayList
  2. class java.util.ArrayList
  3. true
  1. public static void method1() {
  2.     List<Integer> integerArrayList = new ArrayList<>();
  3.     List<String> stringArrayList = new ArrayList<>();
  5.     System.out.println(integerArrayList.getClass());
  6.     System.out.println(stringArrayList.getClass());
  7.     System.out.println(integerArrayList.getClass() == stringArrayList.getClass());
  8. }

将上面的 Java 代码编译成字节码后查看也可看见两个集合都是 java/util/ArrayList

  1. public static method1()V
  2.     L0
  3.     LINENUMBER 14 L0
  4.     NEW java/util/ArrayList
  5.     DUP
  6.     INVOKESPECIAL java/util/ArrayList.<init> ()V
  7.     ASTORE 0
  8.     L1
  9.     LINENUMBER 15 L1
  10.     NEW java/util/ArrayList
  11.     DUP
  12.     INVOKESPECIAL java/util/ArrayList.<init> ()V
  13.     ASTORE 1

因为在运行期间类型擦除的关系，可以通过反射在运行期间修改集合能添加的类，不过添加后查询该集合会抛出 ClassCastException 异常，代码如下。

  1. public static void method4() throws Exception {
  2.     ArrayList<String> stringArrayList = new ArrayList<>();
  3.     stringArrayList.add("hnc");
  4.     stringArrayList.add("boy");
  5.     System.out.println("之前长度：" + stringArrayList.size());
  7.     // 通过反射增加元素
  8.     Class<?> clazz = stringArrayList.getClass();
  9.     Method method = clazz.getDeclaredMethod("add", Object.class);
  10.     method.invoke(stringArrayList, 60);
  12.     System.out.println("之后长度：" + stringArrayList.size());
  13.     // 存的还是 Integer 类型
  14.     // java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
  15.     for (int i = 0; i < stringArrayList.size(); i++) {
  16.         System.out.println(stringArrayList.get(i).getClass());
  17.     }
  18. }

五、总结

泛型在平时的学习中用到的还是挺多的。

  • 数组不支持泛型
  • 泛型的类型不能为基础数据类型
  • 泛型只在编译阶段有效

Java 编程思想 码出高效 Java 开发手册 java 泛型详解