Java泛型编程

1. 泛型类

  泛型类就是具有一个或者多个类型变量的类，在Java集合框架中大量使用了泛型类。通过泛型编程可以使编写的代码被很多不同的类型所共享，大大提高了代码的重用性。

  下面给出一个自定义泛型类的例子：

public class Pair<T>
{
   private T first;
   private T second;
   
   public Pair(T first,T second)
  {
     this.first = first;
     this.second = second;
  }

  public T getFirst()
  { 
     return first;
  }
  
  public T getSecond()
  {
    return second; 
  }

 public void setFirst(T first)
 {
    this.first = first; 
 }
  
 public void setSecond(T second)
 { 
    this.second = second;
 }  
 
}

  使用普通的类名替换类型变量T就可以实例化泛型类型，如：Pair<String>，Java的泛型类类似于C++的模板类。

2. 泛型方法

 Java还可以定义带有类型参数的方法，即泛型方法，泛型方法可以定义在泛型类中，也可以定义在普通类中。

public class ArrayHelper
{
    public static <T> T getMiddle(T[] array)
    {
        return array[array.length / 2];
    }
}

 上述的泛型方法，参数是泛型数组，返回值是泛型变量，在修饰符后面跟有<T>表示这是泛型方法。调用一个泛型方法时在方法名前的"<>"加入具体类型，如：ArrayHelper.<String>getMiddle(new String[]{"left","middle","right"}) ，其实大多数情况下也可以省略<String>。

3. 类型变量的限定

  有些时候，我们希望能使用不同的类型，但又希望这类型能满足某些约束条件，这就要依靠对类型变量的限定。

public class ArrayHelper
{
  public static <T> T max(T[] array)
  { 
      T  max = array[0];
      for(int i = 1; i <  array.length; i++)
        if(array[i].compareTo(max) > 0)
         max = array[i];
      return max;
  }
}

 我们希望使用compareTo方法来比较泛型数组中的每个元素，从而选择出最大的那个元素，而这就要求类型必须实现了Comparable接口，我们就可以对类型变量T作出如下限定:

public class ArrayHelper
{
  public static <T extends Comparable> T max(T[] array)
  { 
      T  max = array[0];
      for(int i = 1; i <  array.length; i++)
        if(array[i].compareTo(max) > 0)
         max = array[i];
      return max;
  }
}

 一个类型变量可以有多个限定，如: <T extends  Comparable & Serializable> 。

4. 类型擦除

 我们定义一个泛型类型后，就可以适配多种不同的类型，然而实际上虚拟机只知道一个原始类型，例如，对于上面定义个Pair<T>，其对应的原始类型如下:

public class Pair
{
   private Object first;
   private Object second;
   
   public Pair(Object first,Object second)
  {
     this.first = first;
     this.second = second;
  }

  public Object getFirst()
  { 
     return first;
  }
  
  public Object getSecond()
  {
    return second; 
  }

 public void setFirst(Object first)
 {
    this.first = first; 
 }
  
 public void setSecond(Object second)
 { 
    this.second = second;
 }  
 
}

 即将T替换成了Object类，实际上是将T替换成限定的类型。假设<T extends Comparable>，则就会将T替换成Comparable，如果有多个限定类型，则替换成第一个限定类型。如果没有限定类型，就替换成Object类，这个过程即类型擦除。

 所以泛型类编译成字节码后就是一个普通的类。

5. 泛型类的继承规则

（1）假设有一个print方法打印雇员对，参数是Pari<Employee>

public void print(Pair<Employee>)
{
   .....
}

      Manager类是Employee类的子类，那么Pair<Manager>是Pair<Employee>的子类么？，可以传入print方法么？答案是不行，Pair<Manager>不是Pair<Employee>的子类。

（2） 永远可以将参数化类型转换成原始类型，如：Pair  pair = new Pair<Manager>("Jack","Mike"); 这是为了与泛型之前的遗留代码能够保持衔接。

（3）泛型类可以像普通类一样继承其他类，实现接口。如： class Pair<T>  implements Comparable 。

6. 通配符类型

 Pair<? extends Fruit> 表示任何泛型Pair类型，它的类型参数是Fruit的子类。Pair<Fruit>和Pair<Apple>都是Pair<? extends Fruit>的子类型。

 Pair<? super Apple>表示任何泛型Pair类型，它的类型参数是Apple的父类。Pair<Fruit>和Pair<Object>都是Pair<? super Apple>的子类型。

 这样，就可以利用参数多态了，修改上面的print方法：

public void print(Pair<? extends Fruit>)
{
   .....
}

 现在就可以传入Pair<Apple>和Pair<Banana>等作为参数了。

 但是对于通配符类型的多态，使用父类变量引用子类实例时，需要注意以下的问题：

Pair<Apple>  apples = new Pair<Apple>(new Apple("apple1"),new Apple("apple2"));
Pair<? extends Fruit>  fruits = apples;
//下面两句调用setFirst方法编译报错，因为编译器只知道Pair中保存类型的是Fruit的子类，但不知道具体是什么类型。
fruits.setFirst(new Apple("apple3"));    
fruits.setFirst(new Banana("banana1"));
//下面调用getFirst方法不会出错，因为编译器知道Pair中保存的类型一定是Fruit的子类，转换成Fruit类不会出错。
Fruit  first = frutis.getFirst();

 即对于<? extends Type> 通配符类型，使用父类变量引用子类实例时，不能对子类实例进行写，只能读。

Pair<Apple>  apples = new Pair<Apple>(new Apple("apple1"),new Apple("apple2"));
Pair<? super Apple>  fruits = apples;
fruits.setFirst(new GoodApple("apple3"));  //这一句调用setFirst方法不会出错，因为编译器知道Pair中保存的类型一定是Apple类的父类，因此，传入Apple类对象或者Apple类的子类对象都是可以的
fruits.setFirst(new Fruit("banana1")); //传入Apple类的父类对象就会编译错误
Fruit first = frutis.getFirst();       //编译不通过，因为编译器知道Pair中保存的类型是Apple类的父类，但不知道具体是什么类，因此，只能赋值给Object类的变量

即对于<? super Type> 通配符类型，使用父类变量引用子类实例时，不能对子类实例进行读，只能写。

参考资料 《Java核心技术》