泛型学习笔记

类型变量（参数）的命名规则
类型变量使用大写形式，且比较短，这是很常见的。在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);

泛型使用的指导原则:

（1）无论何时，只要你能做到，你就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛型化，那么就应该只使用泛型方法

（2）对于一个static的方法而言,如果需要使用泛型能力，就必须使其成为泛型方法.

类型变量的限定

泛型的擦除技术

泛型不支持基本类型

泛型与异常的关系
可以在异常声明中使用类型变量，但不允许在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>的一个对象，也是唯一的一个对象。