本小节我们将学习 Java5 以后出现的一个特性：泛型（Generics）。通过本小节的学习，你将了解到什么是泛型，为什么需要泛型，如何使用泛型，如何自定义泛型，类型通配符等知识。

1. 什么是泛型

泛型不只是 Java 语言所特有的特性，泛型是程序设计语言的一种特性。允许程序员在强类型的程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须做出声明。
我们在上一小节已经了解到，Java 中的集合类是支持泛型的，它在代码中是这个样子的：
3.jpg
代码中的就是泛型，我们把类型像参数一样传递，尖括号中间就是数据类型，我们可以称之为实际类型参数，这里实际类型参数的数据类型只能为引用数据类型。
那么为什么需要泛型呢？我们马上就见分晓。

2. 为什么需要泛型

上一节中，我们在使用ArrayList实现类的时候，如果没有指定泛型，IDEA会给出警告，代码似乎也是可以顺利运行的。请看如下实例：

  1. import java.util.ArrayList;
  3. public class GenericsDemo1 {
  5.     public static void main(String[] args) {
  6.         ArrayList arrayList = new ArrayList();
  7.         arrayList.add("Hello");
  8.         String str = (String) arrayList.get(0);
  9.         System.out.println("str=" + str);
  10.     }
  12. }

运行结果：

  1. str=Hello

虽然运行时没有发生任何异常，但这样做有两个缺点：

  1. 需要强制类型转换： 由于ArrayList内部就是一个Object[]数组，在get()元素的时候，返回的是Object类型，所以在ArrayList外获取该对象，需要强制类型转换。其它的Collection、Map如果不使用泛型，也存在这个问题；
  2. 可向集合中添加任意类型的对象，存在类型不安全风险。例如如下代码中，我们向列表中既添加了Integer类型，又添加了String类型： ```java import java.util.ArrayList;

public class GenericsDemo2 { public static void main(String[] args) { ArrayList arrayList = new ArrayList(); arrayList.add(123); arrayList.add(“Hello”); String str = (String) arrayList.get(0); System.out.println(“element=” + str); } }

  1. 运行结果：
  2. ```c
  3. Exception in thread "main" java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')
  4.     at GenericsDemo2.main(GenericsDemo2.java:8)

由于我们的“疏忽”，列表第 1 个元素实际上是整型，但被我们强制转换为字符串类型，这是行不通的，因此会抛出ClassCastException异常。
使用泛型可以解决这些问题。泛型有如下优点：

  1. 可以减少类型转换的次数，代码更加简洁；
  2. 程序更加健壮：只要编译期没有警告，运行期就不会抛出ClassCastException异常；

  3. 提高了代码的可读性：编写集合的时候，就限定了集合中能存放的类型。

    3. 如何使用泛型

    3.1 泛型使用

    在代码中，这样使用泛型：

    1. List<String> list = new ArrayList<String>();
    2. // Java 7 及以后的版本中，构造方法中可以省略泛型类型：
    3. List<String> list = new ArrayList<>();

    要注意的是，变量声明的类型必须与传递给实际对象的类型保持一致，下面是错误的例子：

    1. List<Object> list = new ArrayList<String>();
    2. List<Number> numbers = new ArrayList(Integer);

    3.2 自定义泛型类

    3.2.1 Java 源码中泛型的定义

    在自定义泛型类之前，我们来看下java.util.ArrayList是如何定义的：
    3.jpg
    类名后面的就是泛型的定义，E不是 Java 中的一个具体的类型，它是 Java 泛型的通配符（注意是大写的，实际上就是Element的含义），可将其理解为一个占位符，将其定义在类上，使用时才确定类型。此处的命名不受限制，但最好有一定含义，例如java.lang.HashMap的泛型定义为HashMap，K表示Key，V表示Value。

    3.2.2 自定义泛型类实例1

    下面我们来自定义一个泛型类，自定义泛型按照约定俗成可以叫，具有Type的含义，实例如下： ```java public class NumberGeneric { // 把泛型定义在类上

    private T number; // 定义在类上的泛型，在类内部可以使用

    public T getNumber() {

    1.  return number;

    }

    public void setNumber(T number) {

    1.  this.number = number;

    }

    public static void main(String[] args) {

    1.  // 实例化对象，指定元素类型为整型
    2.  NumberGeneric<Integer> integerNumberGeneric = new NumberGeneric<>();
    3.  // 分别调用set、get方法
    4.  integerNumberGeneric.setNumber(123);
    5.  System.out.println("integerNumber=" + integerNumberGeneric.getNumber());
    7.  // 实例化对象，指定元素类型为长整型
    8.  NumberGeneric<Long> longNumberGeneric = new NumberGeneric<>();
    9.  // 分别调用set、get方法
    10.  longNumberGeneric.setNumber(20L);
    11.  System.out.println("longNumber=" + longNumberGeneric.getNumber());
    13.  // 实例化对象，指定元素类型为双精度浮点型
    14.  NumberGeneric<Double> doubleNumberGeneric = new NumberGeneric<>();
    15.  // 分别调用set、get方法
    16.  doubleNumberGeneric.setNumber(4000.0);
    17.  System.out.println("doubleNumber=" + doubleNumberGeneric.getNumber());

    }

}

  1. 运行结果：
  2. ```c
  3. integerNumber=123
  4. longNumber=20
  5. doubleNumber=4000.0

我们在类的定义处也定义了泛型：NumberGeneric；在类内部定义了一个T类型的number变量，并且为其添加了setter和getter方法。
对于泛型类的使用也很简单，在主方法中，创建对象的时候指定T的类型分别为Integer、Long、Double，类就可以自动转换成对应的类型了。

3.2.3 自定义泛型类实例2

上面我们知道了如何定义含有单个泛型的类，那么对于含有多个泛型的类，如何定义呢？
我们可以看一下HashMap类是如何定义的。如下是 Java 源码的截图：
3.jpg
参照HashMap类的定义，下面我们来看看如何定义含有两个泛型的类，实例如下：

  1. public class KeyValueGeneric<K,V> { // 把两个泛型K、V定义在类上
  3.     /**
  4.     * 类型为K的key属性
  5.     */
  6.     private K key;
  8.     /**
  9.     * 类型为V的value属性
  10.     */
  11.     private V value;
  13.     public K getKey() {
  14.         return key;
  15.     }
  17.     public void setKey(K key) {
  18.         this.key = key;
  19.     }
  21.     public V getValue() {
  22.         return value;
  23.     }
  25.     public void setValue(V value) {
  26.         this.value = value;
  27.     }
  29.     public static void main(String[] args) {
  30.         // 实例化对象，分别指定元素类型为整型、长整型
  31.         KeyValueGeneric<Integer, Long> integerLongKeyValueGeneric = new KeyValueGeneric<>();
  32.         // 调用setter、getter方法
  33.         integerLongKeyValueGeneric.setKey(200);
  34.         integerLongKeyValueGeneric.setValue(300L);
  35.         System.out.println("key=" + integerLongKeyValueGeneric.getKey());
  36.         System.out.println("value=" + integerLongKeyValueGeneric.getValue());
  38.         // 实例化对象，分别指定元素类型为浮点型、字符串类型
  39.         KeyValueGeneric<Float, String> floatStringKeyValueGeneric = new KeyValueGeneric<>();
  40.         // 调用setter、getter方法
  41.         floatStringKeyValueGeneric.setKey(0.5f);
  42.         floatStringKeyValueGeneric.setValue("零点五");
  43.         System.out.println("key=" + floatStringKeyValueGeneric.getKey());
  44.         System.out.println("value=" + floatStringKeyValueGeneric.getValue());
  45.     }
  46. }

运行结果：

  1. key=200
  2. value=300
  3. key=0.5
  4. value=零点五

3.3 自定义泛型方法

前面我们知道了如何定义泛型类，在类上定义的泛型，在方法中也可以使用。下面我们来看一下如何自定义泛型方法。
泛型方法不一定写在泛型类当中。当类的调用者总是关心类中的某个泛型方法，不关心其他属性，这个时候就没必要在整个类上定义泛型了。
请查看如下实例：

  1. public class GenericMethod {
  3.     /**
  4.     * 泛型方法show
  5.     * @param t 要打印的参数
  6.     * @param <T> T
  7.     */
  8.     public <T> void show(T t) {
  9.         System.out.println(t);
  10.     }
  12.     public static void main(String[] args) {
  13.         // 实例化对象
  14.         GenericMethod genericMethod = new GenericMethod();
  15.         // 调用泛型方法show，传入不同类型的参数
  16.         genericMethod.show("Java");
  17.         genericMethod.show(222);
  18.         genericMethod.show(222.0);
  19.         genericMethod.show(222L);
  20.     }
  21. }

运行结果：

  1. Java
  2. 222
  3. 222.0
  4. 222

实例中，使用来定义show方法的泛型，它接收一个泛型的参数变量并在方法体打印；调用泛型方法也很简单，在主方法中实例化对象，调用对象下的泛型方法，可传入不同类型的参数。

4. 泛型类的子类

泛型类也是一个 Java 类，它也具有继承的特性。
泛型类的继承可分为两种情况：

  1. 子类明确泛型类的类型参数变量；
  2. 子类不明确泛型类的类型参数变量。

下面我们来分别看一下这两种情况。

4.1 明确类型参数变量

例如，有一个泛型接口：

  1. public interface GenericInterface<T> { // 在接口上定义泛型
  2.     void show(T t);
  3. }

泛型接口的实现类如下：

  1. public class GenericInterfaceImpl implements GenericInterface<String> { // 明确泛型类型为String类型
  2.     @Override
  3.     public void show(String s) {
  4.         System.out.println(s);
  5.     }
  6. }

子类实现明确了泛型的参数变量为String类型。因此方法show()的重写也将T替换为了String类型。

4.2 不明确类型参数变量

当实现类不确定泛型类的参数变量时，实现类需要定义类型参数变量，调用者使用子类时，也需要传递类型参数变量。
如下是GenericInterface接口的另一个实现类：

  1. public class GenericInterfaceImpl1<T> implements GenericInterface<T> { // 实现类也需要定义泛型参数变量
  2.     @Override
  3.     public void show(T t) {
  4.         System.out.println(t);
  5.     }
  6. }

在主方法中调用实现类的show()方法：

  1. public static void main(String[] args) {
  2.     GenericInterfaceImpl1<Float> floatGenericInterfaceImpl1 = new GenericInterfaceImpl1<>();
  3.     floatGenericInterfaceImpl1.show(100.1f);
  4.     }

5. 类型通配符

我们先来看一个泛型作为方法参数的实例：

  1. import java.util.ArrayList;
  2. import java.util.List;
  4. public class GenericDemo3 {
  5.     /**
  6.     * 遍历并打印集合中的每一个元素
  7.     * @param list 要接收的集合
  8.     */
  9.     public void printListElement(List<Object> list) {
  10.         for (Object o : list) {
  11.             System.out.println(o);
  12.         }
  13.     }
  14. }

观察上面的代码，参数list的限定的泛型类型为Object， 也就是说，这个方法只能接收元素为Object类型的集合，如果我们想传递其他元素类型的集合，是行不通的。例如，如果传递装载Integer元素的集合，程序在编译阶段就会报错：
3.jpg

Tips： 泛型中的List并不是List的父类，它们不满足继承关系。

5.1 无限定通配符

想要解决这个问题，使用类型通配符即可，修改方法参数处的代码，将<>中间的Object改为?即可：

  1. public void printListElement(List<?> list) {

此处的?就是类型通配符，表示可以匹配任意类型，因此调用方可以传递任意泛型类型的列表。
完整实例如下：

  1. import java.util.ArrayList;
  2. import java.util.List;
  4. public class GenericDemo3 {
  5.     /**
  6.     * 遍历并打印集合中的每一个元素
  7.     * @param list 要接收的集合
  8.     */
  9.     public void printListElement(List<?> list) {
  10.         for (Object o : list) {
  11.             System.out.println(o);
  12.         }
  13.     }
  15.     public static void main(String[] args) {
  16.         // 实例化一个整型的列表
  17.         List<Integer> integers = new ArrayList<>();
  18.         // 添加元素
  19.         integers.add(1);
  20.         integers.add(2);
  21.         integers.add(3);
  22.         GenericDemo3 genericDemo3 = new GenericDemo3();
  23.         // 调用printListElement()方法
  24.         genericDemo3.printListElement(integers);
  26.         // 实例化一个字符串类型的列表
  27.         List<String> strings = new ArrayList<>();
  28.         // 添加元素
  29.         strings.add("Hello");
  30.         strings.add("world");
  31.         // 调用printListElement()方法
  32.         genericDemo3.printListElement(strings);
  33.     }
  34. }

运行结果：

  1. 1
  2. 2
  3. 3
  4. Hello
  5. world

5.2 extends 通配符

extends通配符用来限定泛型的上限。什么意思呢？依旧以上面的实例为例，我们来看一个新的需求，我们希望方法接收的List 集合限定在数值类型内（float、integer、double、byte 等），不希望其他类型可以传入（比如字符串）。此时，可以改写上面的方法定义，设定上界通配符：

  1. public void printListElement(List<? extends Number> list) {

这样的写法的含义为：List集合装载的元素只能是Number自身或其子类（Number类型是所有数值类型的父类），完整实例如下：

  1. import java.util.ArrayList;
  2. import java.util.List;
  4. public class GenericDemo4 {
  5.     /**
  6.     * 遍历并打印集合中的每一个元素
  7.     * @param list 要接收的集合
  8.     */
  9.     public void printListElement(List<? extends Number> list) {
  10.         for (Object o : list) {
  11.             System.out.println(o);
  12.         }
  13.     }
  15.     public static void main(String[] args) {
  16.         // 实例化一个整型的列表
  17.         List<Integer> integers = new ArrayList<>();
  18.         // 添加元素
  19.         integers.add(1);
  20.         integers.add(2);
  21.         integers.add(3);
  22.         GenericDemo4 genericDemo3 = new GenericDemo4();
  23.         // 调用printListElement()方法
  24.         genericDemo3.printListElement(integers);
  26.     }
  27. }

运行结果：

  1. 1
  2. 2
  3. 3

5.3 super 通配符

既然已经了解了如何设定通配符上界，也就不难理解通配符的下界了，可以限定传递的参数只能是某个类型的父类。
语法如下：

  1. <? super Type>

6. 小结

通过本小节的学习，我们知道了使用泛型可以避免强制类型转换，也可以避免运行期就抛出的ClassCastException异常。在使用泛型时，要注意变量声明的泛型类型要匹配传递给实际对象的类型， Java 7 及以后的版本中，构造方法中可以省略泛型类型，推荐直接省略。
我们也学习了如何自定义泛型类和泛型方法，在实际的开发中，我们想要编写比较通用的代码就避免不了使用泛型，大家可以在以后的开发中慢慢体悟。
另外，泛型也是可以继承的。
最后，我们还讲解了类型通配符的概念和使用场景。