JAVA基础之泛型

1、为什么引入泛型

bug是编程的一部分，我们只能尽自己最大的能力减少出现bug的几率，但是谁也不能保证自己写出的程序不出现任何问题。

错误可分为两种：编译时错误与运行时错误。编译时错误在编译时可以发现并排除，而运行时错误具有很大的不确定性，在程序运行时才能发现，造成的后果可能是灾难性的。

使用泛型可以使错误在编译时被探测到，从而增加程序的健壮性。

来看一个例子：

    public class Box {
        private Object object;

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

        public Object get() {
            return object;
        }
    }

按照声明，其中的set()方法可以接受任何java对象作为参数（任何对象都是Object的子类），假如在某个地方使用该类，set()方法预期的输入对象为Integer类型，但是实际输入的却是String类型，就会抛出一个运行时错误，这个错误在编译阶段是无法检测的。例如：

Box box = new Box;  
box.set("abc");  
Integer a = (Integer)box.get();  //编译时不会报错，但是运行时会报ClassCastException

运用泛型改造上面的代码：

public class Box {

    private T t;

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

    public T get() {
        return t;
    }
}

当我们使用该类时会指定T的具体类型，该类型参数可以是类、接口、数组等，但是不能是基本类型。

比如：

Box box = new Box;  //指定了类型类型为Integer
//box.set(“abc”);  该句在编译时就会报错
box.set(new Integer(2));
Integer a = box.get();  //不用转换类型

可以看到，使用泛型还免除转换操作。

在引入泛型机制之前，要在方法中支持多个数据类型，需要对方法进行重载，在引入范型后，可以更简洁地解决此问题，更进一步可以定义多个参数以及返回值之间的关系。

例如

public void write(Integer i, Integer[] ia);
public void write(Double  d, Double[] da);
public void write(Long l, Long[] la);

范型版本为：

public  void write(T t, T[] ta);

总体来说，泛型机制能够在定义类、接口、方法时把“类型”当做参数使用，有点类似于方法声明中的形式参数，如此我们就能通过不同的输入参数来实现程序的重用。不同的是，形式参数的输入是值，而泛型参数的输入是类型。

2、命名规则

类型参数的命名有一套默认规则，为了提高代码的维护性和可读性，强烈建议遵循这些规则。JDK中，随处可见这些命名规则的应用。

• E - Element (通常代表集合类中的元素)
• K - Key
• N - Number
• T - Type
• V - Value
• S,U,V etc. – 第二个，第三个，第四个类型参数……

注意，父类定义的类型参数不能被子类继承。

也可以同时声明多个类型变量，用逗号分割，例如：

public interface Pair {
    public K getKey();
    public V getValue();
}

public class OrderedPair implements Pair {

    private K key;
    private V value;

    public OrderedPair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }
  
    public V getValue() {
        return value;
    }
}

下面的两行代码创建了OrderedPair对象的两个实例。

Pair p1 = new OrderedPair("Even", 8);
Pair  p2 = new OrderedPair("hello", "world");

//也可以将new后面的类型参数省略，简写为：
//Pair p1 = new OrderedPair<>("Even", 8);

//也可以在尖括号内使用带有类型变量的类型变量，例如：
OrderedPair> p = new OrderedPair<>("primes", new Box(...));

泛型是JDK 5.0之后才引入的，为了兼容性，允许不指定泛型参数，但是如此一来，编译器就无法进行类型检查，在编程时，最好明确指定泛型参数。

同样，在方法中也可是使用泛型参数，并且该参数的使用范围仅限于方法体内。例如：

public class Util {
        //该方法用于比较两个Pair对象是否相等。
        //泛型参数必须写在方法返回类型boolean之前
    public static  boolean compare(Pair p1, Pair p2) {
        return p1.getKey().equals(p2.getKey()) &&
               p1.getValue().equals(p2.getValue());
    }
}

Pair p1 = new Pair<>(1, "apple");
Pair p2 = new Pair<>(2, "pear");
boolean same = Util.compare(p1, p2);
//实际上，编译器可以通过Pair当中的类型来推断compare需要使用的类型，所以可以简写为：
// boolean same = Util. compare(p1, p2);

有时候我们想让类型参数限定在某个范围之内，就需要用到extends关键字（extends后面可以跟一个接口，这里的extends既可以表示继承了某个类，也可以表示实现了某个接口），例如，我们想让参数是数字类型：

    class Box {  //类型参数限定为Number的子类

        private T t;

        public Box(T t) {
            this.t = t;
        }

        public void print() {
            System.out.println(t.getClass().getName());
        }

        public static void main(String[] args) {

            Box box1 = new Box(new Integer(2));
            box1.print();  //打印结果：java.lang.Integer
            Box box2 = new Box(new Double(1.2));
            box2.print();  //打印结果：java.lang.Double

            Box box2 = new Box(new String("abc"));  //报错，因为String类型不是Number的子类
            box2.print();
        }

    } 

如果加入多个限定，可以用“&”连接起来，但是由于java是单继承，多个限定中最多只能有一个类，而且必须放在第一个位置。例如：

    class Box {

        //该类型必须为Number的子类并且实现了Cloneable接口和Comparable接口。
        //……
    }

3、泛型类的继承

java是面向对象的高级语言，在一个接受A类参数的地方传入一个A的子类是允许的，例如：

Object someObject = new Object();
Integer someInteger = new Integer(10);
someObject = someInteger;   // 因为Integer是Object的子类

这种特性同样适用于类型参数，例如：

Box box = new Box();
box.add(new Integer(10));   // Integer是Number的子类
box.add(new Double(10.1));  // Double同样是Number的子类

但是，有一种情况很容易引起混淆，例如：

//该方法接受的参数类型为Box
public void boxTest(Box n) { 
    //……
}
//下面两种调用都会报错
boxTest(Box);
boxTest(Box);

虽然Integer和Double都是Number的子类，但是Box与Box并不是Box的子类，不存在继承关系。Box与Box的共同父类是Object。

1.png

以JDK中的集合类为例，ArrayList 实现了 List接口，List接口继承了 Collection接口，所以，ArrayList是List的子类，而非List的子类。三者的继承关系如下：

2.png

4、类型推断

先来看一个例子：

    public class Demo {

        static  T pick(T a1, T a2) {
            return a2;
        }

    }

静态方法pick()在三个地方使用了泛型，分别限定了两个输入参数的类型与返回类型。调用该方法的代码如下：

Integer ret = Demo. pick(new Integer(1), new Integer(2));

前文已经提到，上面的代码可以简写为：

Integer ret = Demo.pick(new Integer(1), new Integer(2));

因为java编译器会根据方法内的参数类型推断出该方法返回的类型应该为Integer，这种机制称为类型推断（Type Inference）。

那么问题来了，加入两个输入参数为不同的类型，应该返回什么类型呢？

例如：

pick("d", new ArrayList());

第一个参数为String类型，第二个参数为ArrayList类型，java编译器就会根据这两个参数类型来推断，尽量使返回类型为最明确的一种。本例中，String与ArrayList都实现了同样的接口——Serializable，当然，他们也是Object的子类，Serializable类型显然比Object类型更加明确，因为它的范围更小更细分，所以最终的返回类型应该为Serializable：

Serializable s = pick("d", new ArrayList());

在泛型类实例化的时候同样可以利用这种机制简化代码，需要注意的是，尖括号“<>”在此时是不能省略的。例如：

Map> myMap = new HashMap>();
//编译器能推断出后面的类型，所以可以简化为：
Map> myMap = new HashMap<>();
//但是，不能简化为：
Map> myMap = new HashMap();
//因为HashMap()是HashMap原始类型（Raw Type）的构造函数，而非HashMap>的构造函数，如果不加“<>”编译器不会进行类型检查

5、通配符

上文中我们提到过一个例子：

public void boxTest(Box n){
        //……
}

该方法只能接受Box这一种类型的参数，当我们输入一个Box或者Box时会报错，尽管Integer与Double是Number的子类。可是如果我们希望该方法可以接受Number以及它的任何子类，该怎么办呢？

这时候就要用到通配符了，改写如下：

public void boxTest(Box n){
        //……
}

? extends Number就代表可以接受Number以及它的子类作为参数。这种声明方式被称为上限通配符（upper bounded wildcard）。

相反地，如果我们希望该方法可以接受Integer，Number以及Object类型的参数怎么办呢？应该使用下限通配符（lower bounded wildcard）：

public void boxTest(Box n){
        //……
}

? super Integer代表可以接受Integer以及它的父类作为参数。

如果类型参数中既没有extends 关键字，也没有super关键字，只有一个?，代表无限定通配符（Unbounded Wildcards）。

通常在两种情况下会使用无限定通配符：

• 如果正在编写一个方法，可以使用Object类中提供的功能来实现
• 代码实现的功能与类型参数无关，比如List.clear()与List.size()方法，还有经常使用的Class方法，其实现的功能都与类型参数无关。

来看一个例子：

public static void printList(List