Java基础教程(21)--泛型

一.为什么使用泛型

  泛型意味着编写的代码可以被很多不同类型的对象所重用。例如，我们不希望为存放String和Integer对象的集合设计不同的类。现在的ArrayList类可以存放任何类型的对象，但是在Java中增加泛型之前已经有了一个ArrayList类，它是使用继承来实现泛型的。这个ArrayList类只维护一个Object数组：

public class ArrayList {
    private Object [] elementData ;
    public Object get (int i) {...}
    public void add (Object o) {...}
}

  这样存在两个问题。第一是可以向集合中添加任何对象：

ArrayList collection = new ArrayList();
collection.add(new Integer(0));
collection.add("string");

  第二是在获取值时必须进行强制类型转换：

Integer i0 = (Integer)collection.get(0);

  如果我们默认这个集合是用来存放Integer对象的，那么下面的类型转换可以通过编译，但是在运行时会产生错误：

Integer i1 = (Integer)collection.get(1);

  泛型提供了一个更好的解决方案：类型参数。现在的ArrayList类有一个类型参数用来指示元素的类型：

ArrayList collection = new ArrayList();

  这使得代码具有更好的可读性，一看就知道这个集合中存放的是Integer对象。

注：在Java SE 7及以后的版本中，构造函数中可以省略泛型类型。也就是说，上面的语句实际上可以这么写：

ArrayList collection = new ArrayList<>();

  编译器也可以很好地利用这个信息。当调用get的时候，不需要进行强制类型转换，编译器就知道返回值类型是Integer，而不是Object：

Integer i0 = collection.get(0);

  而且，在插入元素时编译器会进行检査，避免插人错误类型的对象。例如：

collection.add("string");

  这句代码是无法通过编译的。出现编译错误比运行时出现类的强制类型转换异常要好得多。类型参数的魅力在于可以使程序具有更好的可读性和安全性。

二.泛型类型

  泛型类型就是将参数类型化的类或接口。就是具有一个或多个类型参数的类。我们先定义一个简单的Box类，然后使用泛型对它进行改造。

1.一个简单的Box类

  我们可以将Box类看作是一个盒子，它可以用来存放一个对象。这里我们使用一个Object类型的成员变量来存放对象，并且需要提供两个方法：一个是将对象放入盒子的set方法，另一个是获取盒子中的对象的get方法。

public class Box {
    private Object object;

    public void set(Object object) { this.object = object; }
    public Object get() { return object; }
}

  由于它内部维护的是一个Object对象的引用，因此你可以放入任何类型的对象。但是当你取出对象时，你必须进行强制类型转换。这样就会存在一个问题，如果你存入的对象类型与你转换的类型不一致，将会在运行时出现异常，但是编译器却无法在编译时期发现这个问题。例如：

Box b = new Box();
b.set("box");
Integer i = (Integer) b.get();

  上面的代码可以通过编译，但是会在运行的时候抛出一个ClassCastException。

2.使用泛型的Box类

  泛型类使用如下的语法定义：

class ClassName {...}

  类名后面是类型参数（也称类型变量），使用一对尖括号<>括起来，一个类中可以有多个类型参数。
  下面是使用泛型改造后的Box类：

public class Box {
    private T t;

    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

  所有的Object都被替换成了类型变量T。在使用时，类型变量可以是任何非基本数据类型。
  泛型接口的语法与泛型类类似：

interface InterfaceName {...}

3.类型参数的命名惯例

  按照惯例，类型参数名称是单个大写字母。这与我们已经了解的变量命名规范有很大的出入，但是这有充分的理由：如果没有这种约定，就很难区分类型变量和类或接口的名称。
  下面是最常用的类型参数的名称：

• E - 元素（广泛应用于集合中）
• K - 键
• V - 值
• N - 数字
• T - 类型
• S，U，V等 - 第二、第三、第四类型

4.调用和实例化泛型类型

  要在代码中使用Box类，必须执行泛型类型调用，也就是将T替换为具体的类型，比如Integer：

Box integerBox;

  你可以把泛型类型调用看作是普通的方法调用，但是不同于将参数传递给方法，泛型类型调用将类型参数（在这个例子中是Integer）传递给泛型类。
  正如其他的变量声明一样，上面的代码并没有创建Box对象，它只是声明了一个可以引用装有Integer对象的Box对象的引用。
  泛型类型调用也被称作是类型参数化。
  要实例化这个类，可以像实例化其他类一样使用new关键字，但是要在类名和小括号之间加上：

Box integerBox = new Box();

5.钻石运算符

  在Java SE 7及以后的版本中，在调用泛型类的构造方法时可以省略尖括号中的类型参数，这对尖括号被称为钻石运算符。例如，你可以使用下面的语句来实例化Box：

Box integerBox = new Box<>();

6.原始类型

  原始类型是指没有类型参数的泛型类或接口。例如下面的泛型类Box：

public class Box {
    public void set(T t) { /* ... */ }
    // ...
}

  要创建一个类型参数化的Box，需要为类型参数T提供一个实际的类型：

Box intBox = new Box<>();

  如果没有提供实际的类型，将会创建一个Box的原始类型：

Box rawBox = new Box();

  因此，Box就是Box的原始类型。但是，非泛型类或接口不是原始类型。
  原始类型多出现在遗留代码中，这是因为很多类或接口（例如集合类）在JDK 5.0之前不是泛型的。在使用原始类型时，你实际上已经获得了预泛型行为。为了向后兼容，允许将一个参数化的类型赋值给原始类型：

Box stringBox = new Box<>();
Box rawBox = stringBox;           // OK

  但是如果你把原始类型赋值给参数化的类型，就会产生警告：

Box rawBox = new Box();           // rawBox is a raw type of Box
Box intBox = rawBox;     // warning: unchecked conversion

  如果使用原始类型调用泛型类型中定义的使用了泛型的方法，也会产生警告：

Box stringBox = new Box<>();
Box rawBox = stringBox;
rawBox.set(8);                    // warning: unchecked invocation to set(T)

  警告显示原始类型将会绕过泛型类型检查，将不安全代码的捕获推迟到运行时。因此，应该避免使用原始类型。

三.泛型方法

  泛型方法是指引入了自己独有的类型参数的方法。这类似于声明泛型类型，但类型参数的使用范围仅限于声明它的方法。允许使用静态和非静态泛型方法，以及泛型构造方法。
  定义泛型方法时，要将使用尖括号包围的类型参数列表放在修饰符之后，返回值之前。
  下面的Util类中定义了一个泛型方法compare，这个方法可以用来比较两个Pair对象：

public class Util {
    public static  boolean compare(Pair p1, Pair p2) {
        return p1.getKey().equals(p2.getKey()) && p1.getValue().equals(p2.getValue());
    }
}

class Pair {
    private K key;
    private V value;
    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }
    public void setKey(K key) { this.key = key; }
    public void setValue(V value) { this.value = value; }
    public K getKey()   { return key; }
    public V getValue() { return value; }
}

  调用该方法的语法如下：

Pair p1 = new Pair<>(1, "apple");
Pair p2 = new Pair<>(2, "pear");
boolean same = Util.compare(p1, p2);

  上面的代码中显式提供了类型参数。一般来说，可以省略类型参数，编译器将会自动推断出需要的类型。

Pair p1 = new Pair<>(1, "apple");
Pair p2 = new Pair<>(2, "pear");
boolean same = Util.compare(p1, p2);

  这个特性被称为类型推断，允许将泛型方法作为普通方法调用，而无需在尖括号之间指定类型。我们稍后将会进一步讨论有关类型推断的内容。
  构造方法也可以是泛型方法，并且非泛型类也可以拥有泛型构造方法，例如：

class MyClass {
     MyClass(T t) {
        ...
    }
}

四.有界类型参数

  有时你可能希望限制类型参数的类型。例如，对数字进行操作的方法可能只想接受Number及其子类的实例。这正是有界类型参数的用途。
  要声明有界类型参数，需要在类型参数后面使用extends关键字，然后跟上这个类型参数的上界。需要注意的是，在这种情况下，extends既可以用于表示继承（对于类而言），又可以用于表示实现（对于接口而言）。

public class Box {
    private T t;

    public void set(T t) {
        this.t = t;
    }
    public T get() {
        return t;
    }
    public  void inspect(U u){
        System.out.println("T: " + t.getClass().getName());
        System.out.println("U: " + u.getClass().getName());
    }
    public static void main(String[] args) {
        Box integerBox = new Box();
        integerBox.set(new Integer(10));
        integerBox.inspect("some text"); // error: argument must be Number or its subclass
    }
}

  上面的程序将会编译失败，因为inspect方法只接受Number类及它的子类的实例作为参数。
  一个类型参数可以有多个上界：

  如果一个类型参数有多个上界，那么这些上界中最多只能有一个类，并且这个类必须是列表中的第一个：

Class A { /* ... */ }
interface B { /* ... */ }
interface C { /* ... */ }

class D  { /* ... */ }

  如果A没有放在第一个，将会产生一个编译错误。

五.泛型，继承和子类型

  正如我们所知，可以将子类的实例赋值给父类类型的变量。例如，可以将Integer类的实例赋值给Number类型的变量，因为Integer是Number的子类。

Number someNumber = new Integer(10);

  在泛型中也是如此，例如：

Box box = new Box();
box.set(new Integer(10));

  现在考虑以下方法：

public void boxTest(Box n) { /* ... */ }

  这个方法接受一个Box类型的参数。我们是否可以传递Box或Box类型的参数呢？答案是否定的。因为Box和Box不是Box的子类。在使用泛型编程时，这是一个常见的误解，但这是一个需要学习的重要概念。

  给定两个具体类型A和B（例如，Number和Integer），MyClass与MyClass无关，无论A和B是否相关。MyClass和MyClass的公共父类是Object。
  两个泛型类型的关系是通过它们之间的继承（或实现）语句确定的，而不是通过类型参数之间的关系确定的。只要两个泛型类型之间存在继承（或实现）关系，并且不改变类型参数，就会在类型之间保留子类型关系。
  使用ArrayList类作为示例。ArrayList实现了List接口，而List接口又继承了Collection接口。所以ArrayList是List和Collection的子类型，List是Collection的子类型。只要不改变参数类型，他们之间就存在子类型关系：

  现在假设我们要定义一个自己的接口PayLoadList，它继承自List接口，同时引入了新的类型参数P：

interface PayloadList extends List {
  void setPayload(int index, P val);
  ...
}

  只要我们保证传递给类型参数E的类型和List一致，无论传递给P的类型是什么，这个接口都是List的子类型，例如：

• PayloadList
• PayloadList
• PayloadList

六.类型推断

  类型推断是Java编译器的一种根据方法调用和对应的声明来推断类型参数的具体类型的能力。类型推断试图找到适用于所有参数的最贴切的类型。例如：

static  T pick(T a1, T a2) { return a2; }
Serializable s = pick("d", new ArrayList());

  在上面的例子中，T将会被推断为Serializable类型。因为a1是String类型，a2是ArrayList类型，因此编译器将会寻找它们的共同超类型，也就是Serializable类型。

1.类型推断和泛型方法

  在泛型方法中我们已经提到了类型推断，它使我们能够像调用普通方法一样调用泛型方法，而无需在尖括号之间指定类型。考虑下面的例子：

public class BoxDemo {
    public static  void addBox(U u, List> boxes) {
        Box box = new Box<>();
        box.set(u);
        boxes.add(box);
    }
    public static  void outputBoxes(List> boxes) {
        int counter = 0;
        for (Box box: boxes) {
            U boxContents = box.get();
            System.out.println("Box #" + counter + " contains [" + boxContents.toString() + "]");
            counter++;
        }
    }
    public static void main(String[] args) {
        ArrayList> listOfIntegerBoxes = new ArrayList<>();
        BoxDemo.addBox(Integer.valueOf(10), listOfIntegerBoxes); // statement 1
        BoxDemo.addBox(Integer.valueOf(20), listOfIntegerBoxes);          // statement 2
        BoxDemo.outputBoxes(listOfIntegerBoxes);
    }
}

  上面的例子输出如下：

Box #0 contains [10]
Box #1 contains [20]

  泛型方法addBox定义了一个类型参数U。当调用addBox时，在方法前面的尖括号中放入具体的类型，正如上面的statement 1：

BoxDemo.addBox(Integer.valueOf(10), listOfIntegerBoxes);

  不过，大多数情况下，编译器可以根据方法调用来推断出类型参数的具体类型，因此可以省略方法名后面的尖括号和类型，正如上面的statement 2：

BoxDemo.addBox(Integer.valueOf(20), listOfIntegerBoxes);

2.类型推断和构造方法

  在泛型类和非泛型类中，都可以包含泛型构造方法（换句话说就是可以引入它们自己的类型参数）。首先我们看一个泛型类的例子：

class MyClass {
     MyClass(T t) {
        ...
    }
}

  首先需要明确一点的是，在实例化一个泛型类时，构造方法后面的尖括号里的参数列表与声明泛型类时类名后的尖括号里的参数列表是一一对应的，也就是说，无论构造方法是不是泛型方法，它都是提供给泛型类引入的类型参数使用的。这与普通的泛型方法不一样，普通的泛型方法在调用时尖括号中的参数是提供给该方法使用的。这就意味着，如果一个泛型类包含泛型构造方法，那么在实例化该泛型类时，无论构造方法后的尖括号中是否省略了类型参数列表，该构造方法始终需要推断出自己引入的类型参数的具体类型。因此，可以像下面这样实例化上面的泛型类：

MyClass myObject1 = new MyClass("obj1"); // statement 1
MyClass myObject2 = new MyClass<>("obj2");        // statement 2

  上面的statement 1中，构造方法后面提供了X的类型，因此无需推断，但由于无法提供T的类型，因此编译器需要从构造方法的参数中推断出其类型String；在statement 2中，X和T的类型都没有提供，因此均需要推断。
  下面再来看一个非泛型类的例子：

class MyClass {
     MyClass(T t) {
        ...
    }
}

  因为这是一个非泛型类，在实例化时构造方法后面不能使用尖括号，因此仍然无法提供该泛型构造方法需要的类型信息，那么T的类型必须通过推断得出：

MyClass myObject = new MyClass("obj");

  经过类型推断可以得出T的类型是String。

七.通配符

  在泛型程序设计中，问号（?）被称为通配符，它表示未知的类型。通配符可以被用在很多场景中：参数、域或局部变量的类型，有时候也用在返回值类型中（不过更好的编程实践是使用具体的返回值类型）。下面将更详细地讨论通配符。

1.上界通配符

  可以使用上界通配符来放宽对变量的限制。例如，如果你的方法接受的参数是一个List，它里面的元素可以是Number以及它的子类的实例，你可以使用上界通配符来实现这一点。
  要声明一个上界通配符，在尖括号中使用?，后面跟上extends关键字和它的上界。在这种情况下，extends既可以用于表示继承（对于类而言），又可以用于表示实现（对于接口而言）。
  要编写适用于Number及其子类类型的集合的方法，你可以指明List。List比List更严格，因为前者只接受Number类型的集合，而后者可以接受Number及其子类类型的集合。
  下面的sumOfList方法返回一个集合中的数字的总和：

public static double sumOfList(List list) {
    double s = 0.0;
    for (Number n : list)
        s += n.doubleValue();
    return s;
}

  以下的代码使用了一个Integer集合，将会输出sum = 6.0：

List li = Arrays.asList(1, 2, 3);
System.out.println("sum = " + sumOfList(li));

  下面的代码使用了Double集合，将会输出sum = 7.0：

List ld = Arrays.asList(1.2, 2.3, 3.5);
System.out.println("sum = " + sumOfList(ld));

2.无界通配符

  无界通配符只用到了问号（?），例如List。在以下两种场景中无界通配符很有用：

• 对于通配符表示的类型，你编写的方法只用到了来自Object类的方法。
• 你的代码只使用到了泛型类中不依赖于类型参数的方法，例如List的size()和clear()方法。

  考虑以下方法：

public static void printList(List