Java学习总结之泛型程序设计

泛型程序设计

泛型程序设计意味着编写的代码可以被很多不同类型的对象所重用。例如ArrayList类可以聚集任何类型的对象，这是一个泛型程序设计的实例。实际上，在Java增加泛型类之前已经有一个ArrayList类，下面来研究泛型程序设计机制是如何演变的。

类型参数的好处

在Java增加泛型类之前，泛型程序设计是用继承实现的。ArrayList类只维护一个Object引用的数组：

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

这种方法有两个问题，我们以一个保存文件名的files数组列表为例：

1. 当获取一个值时必须进行强制类型转换：

ArrayList files = new ArrayList();
. . .
String filename = (String)files.get(0);

2. 当添加一个值时不进行类型检查，可以添加任何类的对象：

files.add(new File(". . ."));

此调用在编译和运行时都不会出错，但如果将get的结果强制转换为String会产生一个错误

为了解决上述问题，引入了类型参数。ArrayList有一个类型参数用来指示元素类型：ArrayList files = new ArrayList();，注意前后两个T必须一致，不能是子类和父类！因为在泛型中，如果A是B的子类，泛型类和泛型类之间并没有任何的关系。在Java SE 7及以后的版本，构造函数可以省略类型参数，即ArrayList files = new ArrayList<>();
这种方法有三个好处：
1)get得到的值不必进行强制类型转换
2)向数组列表中添加对象时会进行类型检查，如果不符合类型，无法通过编译，出现编译错误比类在运行时出现类的强制转换异常要好得多
3)程序具有更好的可读性，比如ArrayList files一看就是聚集了String对象的数组列表

定义简单的泛型类

一个泛型类就是具有一个或多个类型变量的类，下面使用一个简单的Pair类作为例子：

public class Pair
{
    private T first;
    private T second;
    
    public Pair() {first = null; second = null}
    public Pair(T first,T second) {this.first = first; this.second = second}
    
    public void setFirst(T newValue) {first = newValue;}
    public void setSecond(T newValue) {second = newValue;}
 }

Pair类引入了一个类型变量T，用尖括号括起来，并放在类名的后面。注意这里的T只是指定了一种类型，不代表类只有一个属性成员，而表示接下来类中出现的T都和尖括号里的类型保持一致,即类定义的类型变量指定方法返回类型以及域和局部变量的类型。
泛型类可以有多个类型变量，如可以定义两个域类型不同的Pair类public class Pair {. . .}
类型变量命名规则：E表示集合的元素类型，K和V分别表示表的键和值的类型，T(需要时还可以用临近的字母U和S)表示“任意类型”。
实际使用中将类定义尖括号里的T替换为具体类型，类中的T也会进行相应的替换，所以，泛型类可以看作普通类的工厂

泛型方法

前面介绍了如何定义一个泛型类，下面我们来定义一个带有类型参数的简单泛型方法：

class ArrayAlg
{
    public static  T getMiddle(T...a)
    {
        return a[a.length / 2];
    }
}

注意：
1)类型变量放在修饰符(这里是public static)的后面，返回类型的前面
2)泛型方法可以定义在普通类中，也可以定义在泛型类中
3)当调用一个泛型方法时，在方法名前的尖括号中放入具体的类型：

String middle = ArrayAlg.getMiddle("John","Q.","Public");

或者在Java1.7/1.8利用type inference，让Java自动推导出相应的类型参数：

String middle = ArrayAlg.getMiddle("John","Q.","Public");

我们注意到上面的泛型方法的参数必须是T类型，如果想要传入T类型的子类怎么办呢？我们可以把改为，这样参数就可以接受T类型以及它的子类。类似的则表示参数可以为T类型以及它的超类。以上统称为通配符。

类型变量的限定

有时，类或方法需要对类型变量加以约束。下面是一个典型的例子，我们要计算数组中的最小元素：

class ArrayAlg
{
    public static  T min(T[] a)
    {
        if(a == null || a.length == 0) return null;
        T smallest = a[0];
        for(int i = 1; i < a.length;i++)
            if(smallest.compareTo(a[i]) > 0)
                smallest = a[i];
        return smallset;
    }
}

我们会发现一个问题，smallest的类型为T，既可以是任何一个类的对象，如何保证T类型有compareTo方法呢？解决方法是限制T为实现了Comparable接口的类，即将泛型方法定义改为public static T min(T[] a)
注意：
1)限定类时如果实现的是接口也用extends关键字，如上面的T extends Comparable
2)只需要在尖括号里限定，之后的T不用再加限定

一个类型变量或通配符可以有多个限定，用'&'分隔限定类型，用逗号分隔类型变量，例如：T extends Comparable & Serializable 可以有多个接口限定和至多一个类限定，将标记接口(空接口)放在限定列表的末尾，如果用一个类作为限定，它必须是限定列表中的第一个。
这种限定方式称为边界符。

PECS原则

上面我们看到了类似的用法，利用它我们可以从list里面get元素，那么我们可不可以往list里面add元素呢？我们来尝试一下：

public class GenericsAndCovariance {
    public static void main(String[] args) {
        // Wildcards allow covariance:
        List flist = new ArrayList();
        // Compile Error: can't add any type of object:
        // flist.add(new Apple())
        // flist.add(new Orange())
        // flist.add(new Fruit())
        // flist.add(new Object())
        flist.add(null); // Legal but uninteresting
        // We Know that it returns at least Fruit:
        Fruit f = flist.get(0);
    }
}

答案是否定，Java编译器不允许我们这样做，为什么呢？对于这个问题我们不妨从编译器的角度去考虑。因为List flist它自身可以有多种含义：

List flist = new ArrayList();
List flist = new ArrayList();
List flist = new ArrayList();

• 当我们尝试add一个Apple的时候，flist可能指向new ArrayList();
• 当我们尝试add一个Orange的时候，flist可能指向new ArrayList();
• 当我们尝试add一个Fruit的时候，这个Fruit可以是任何类型的Fruit，而flist可能只想某种特定类型的Fruit，编译器无法识别所以会报错。

所以对于实现了的集合类只能将它视为Producer向外提供(get)元素，而不能作为Consumer来从外获取(add)元素。
如果我们要add元素应该怎么做呢？可以使用：

public class GenericWriting {
    static List apples = new ArrayList();
    static List fruit = new ArrayList();
    static  void writeExact(List list, T item) {
        list.add(item);
    }
    static void f1() {
        writeExact(apples, new Apple());
        writeExact(fruit, new Apple());
    }
    static  void writeWithWildcard(List list, T item) {
        list.add(item)
    }
    static void f2() {
        writeWithWildcard(apples, new Apple());
        writeWithWildcard(fruit, new Apple());
    }
    public static void main(String[] args) {
        f1(); f2();
    }
}

这样我们可以往容器里面添加元素了，但是使用super的坏处是以后不能get容器里面的元素了，原因很简单，我们继续从编译器的角度考虑这个问题，对于List list，它可以有下面几种含义：

List list = new ArrayList();
List list = new ArrayList();
List list = new ArrayList