泛型学习笔记

类型变量（参数）的命名规则
类型变量使用大写形式，且比较短，这是很常见的。在Java库中，使用变量E表示集合的元素类型，K和V表示表的关键字与值的类型。T（需要时还可以用临近的字母U和S）表示"任意类型"。

泛型类


泛型方法
示例：
    class ArrayAlg
    {
    public static <T> T getMiddle(T[] a)
    {
        return a[a.length/2];
    }
    }
调用泛型方法
String[] names = {"John","Q","Public"};
String middle = ArrayAlg.<String>getMiddle(names);
你也可以使用泛型类型推断功能，直接调用如下: String middle = ArrayAlg.getMiddle(names);

类型变量的限定

泛型的擦除技术

泛型不支持基本类型

泛型与异常的关系
可以在异常声明中使用类型变量，但不允许在catch子句中使用类型变量。
public static <T extends Throwable> void dowork(T t) throws T//OK
{
    try{
        do work
    }catch(Throwable realCause){
        t.initCause(realCause);
        throw t;
    }
}
public static <T extends Throwable> void doWork(Class<T> t)
{
    try{
        do work
    }catch(T e){//ERROR--can't catch type variable
        Logger.global.info(...)
    }
}

禁用参数化类型的数组
不能创建泛型化的数组

泛型类型的实例化
new T();//ERROR
new T[2];//ERROR
不能实例化泛型类型。但是，通过调用Class.newInstance和Array.newInstance方法，可以利用反射构造泛型对象和数组。

不能在静态域或方法中引用类型变量（can't make a static reference to the non-static type）
public class Singleton<T>
{
    public static T getSingleInstance(){//ERROR
        if(singleInstance == null)
            construct new instance of T
        return singleInstance;
    }
    private static T singleInstance;//ERROR
}
禁止使用带有类型变量的表态域和方法.

带有超类型限定的通配符可以向泛型对象写入，带有子类型限定的通配符可以从泛型对象读取（不太好理解，可以参与JAVA2核心技术）
public class Pair<T> {
    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 T getFirst() {
        return first;
    }
    public void setFirst(T first) {
        this.first = first;
    }
    public T getSecond() {
        return second;
    }
    public void setSecond(T second) {
        this.second = second;
    }
}
子类型限定的通配符
    Manager ceo = new Manager();
    Manager cto = new Manager();
    LowlyEmployee lowlyEmployee = new LowlyEmployee();
    Pair<Manager> managerBuddies = new Pair<Manager>(ceo,cto);
    Pair<? extends Employee> wildcardBuddies = managerBuddies;
    //带有子类型限定的通配符可以从泛型对象读取
    Employee employee = wildcardBuddies.getFirst();

Pair<? extends Employee>
    public void setFirst(? extends Employee first) //禁用
    public ? extends Employee getSecond() //可以用，但返回类型至少为Employee或更大

超类型限定的通配符
    Manager ceo = new Manager();
    Manager cto = new Manager();
    LowlyEmployee lowlyEmployee = new LowlyEmployee();
    Pair<Manager> managerBuddies = new Pair<Manager>(ceo,cto);
    Pair<? super Manager> wildcardBuddies = managerBuddies;
    result.setSecond(new Manager(){}); //可以写但必须是Manager类型的
    Object object = result.getFirst(); //如果读，返回的必须是Object类型的

Pair<? super Manager>
    public void setFirst(? super Manager first) //参数只能传Manager(或Manager的子类)
    public ? super Manager getSecond() //可以用，但返回类型必须为Object(这样也失去了泛型的意义)



无限制的通配符
Pair<?>有方法如下：
    ？getFirst() //getFirst的返回值只能赋值给一个Object
    void setFirst(?> //禁止使用，即使传入学Object也不可使用
    public static boolean hasNulls(Pair<?> p){ //不需要实际的类型
        return p.getFirst() == null || p.getSecond() == null;
    }
    也可以使用泛型方法来实现上述的功能，但是带有通配符的版本可读性更强
    public static <T> boolean hasNulls(Pair<T> p)


使用Class<T>参数进行类型匹配
Employee.class是类型Class<Employee>的一个对象，也是唯一的一个对象。