泛型

它是在JavaSE5中引入的特性。泛型实现了类型参数化的概念，使代码可以应用于多种类型。使用泛型之场景之一就是创建容器类。如下：

// 使用类型参数(即紧跟类名后尖括号中的类名)创建容器且容器只能存放String对象
List<String> stringList = new ArrayList<String>();
stringList.add("str1");
stringList.add(1); // 编译错误：List<String>不能存放int 
String str = stringList.get(0); // 不需要进行类型转换

// 不使类型参数时如下
List list = new ArrayList();
list.add("str1");
String item = (String)list.get(0); // 进行类型转换

使用泛型创建容器类时的好处，第一能在编译期检查容器中的类型是否正确；第二在调用容器的方法时不需要转换成指定的参数类型。



泛型接口和类定义


在接口名称或类名称后添加尖括号及类型参数名称，多个类型参数用逗号分隔 


// 泛型类
class Class<T> {
}


// 泛型接口
interface Interface<G> {
}



泛型方法


这个方法所在的类可以是泛型类，也可以不是泛型类。无论何时，只要你能做到，你就应该尽量使用泛型方法，因为它可以使事情更清楚明白。定义泛型方法，只需要将泛型参数列表置于返回值之前，如下： 


import java.util.ArrayList;
import java.util.Date;

public class GeneratorMethods {

    public <T, V, U> void f(T x, V y, U u) {
        System.out.println(x.getClass().getName() + "=="
            + y.getClass().getName() + "==" + u.getClass().getName());
    }

    public static void main(String[] args) {
        GeneratorMethods gm = new GeneratorMethods();
        gm.f("", new ArrayList<Integer>(), new Long(10));
        gm.f(1, new Date(), "str");
    }
}

当使用泛型类时，必须在创建对象的时候指定类型参数的值，而使用泛型方法的时候，通常不必指明参数类型，因为编译器会为我们找出具体的类型。


类型参数的擦除

在泛型代码内部，无法获得任何有关泛型参数类型的信息。下面程序进行泛型类的参数类型的输出。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

class Frob {}
class Fnorkle {}
class Quark<Q> {}
class Particle<POSITION, MOMENTUM> {}

public class LostInformation {
    
    public static void main(String[] args) {
        List<Frob> list = new ArrayList<Frob>();

        // Arrays.toString()：输出数组的内容
        // Class.getTypeParameters()：输出泛型类的参数类型
        System.out.println(Arrays.toString(list.getClass().getTypeParameters()));
        
        Map<Frob, Fnorkle> map = new HashMap<Frob, Fnorkle>();
        System.out.println(Arrays.toString(map.getClass().getTypeParameters()));
        
        Quark<Fnorkle> quark = new Quark<Fnorkle>();
        System.out.println(Arrays.toString(quark.getClass().getTypeParameters()));
        
        Particle<Long, Double> p = new Particle<Long, Double>();
        System.out.println(Arrays.toString(p.getClass().getTypeParameters()));
    }
}

输出结果为：

[E]
[K, V]
[Q]
[POSITION, MOMENTUM]

在这些输出的结果中，能够发现的只是用作参数占位符的标识符，而不是实例化泛型类时转入类的类型参数，这并非有用的信息。

边界

边界使得你可以在用于泛型的参数类型上设置限制条件。使用无界泛型参数时，只能调用Object类中方法，而有边界的类型参数可以调用一个指定的子集。

如下所示

import java.awt.Color;

interface HasColor {
    Color getColor();
}

// 泛型重用了extends关键字，这里表示“T”为HasColor的任何子类
class Colored<T extends HasColor> {
    T item;

    Colored(T item) {
        this.item = item;
    }

    // 因为确定了“T”是HasColor的子类，所以可用调用HasColor中的方法
    Color color() {
        return item.getColor();
    }
}