关于JAVA泛型中的通配符类型

　　之前对JAVA一知半解时就拿起weiss的数据结构开始看，大部分数据结构实现都是采取通配符的思想，好处不言而喻。

　　　　首先建立两个类employee和manager，继承关系如下。其次Pair类是一个简单的泛型类。

　　　　

　　　　  通配符的作用就是在泛型设计程序中允许类型参数变化

---

　　　　子类型限定

Pair<? extends Employee>

　　　　  extends可以理解为是向下的 ↓

　　　　即所有Employee的子类都是可以的，可以理解为Pair<Manager>是Pair<? extends Employee>的子类型

　　　　

 /*
 打印雇员对的方法
 */
 public static void printBuddies(Pair<? extends Employee> p)
 {
     Employee first=p.getFirst();
     Employee second-p.getSecond();
     System.out.println(...)
 }

　　　　上例的方法可以将Pair<Manager>传递过去

---

　　　　通配符限定还有个超类型限定

? super Manager

　　　　super关键字如同字面意思，是↑的，即所有Manager父类都是可以的。

　　　　

 /*
 数组放入奖金最高和最低的经理
 */
 public static void minmaxBonus(Manager[] a,Pair<? super Manager> result)
 {
     if(a.length==0)
         return;
     Manager min=a[0];
     Manager max=a[0];
     for(int i=0;i<a.length;i++)
     {
         if(min.getBonus()>a[i].getBonus())
             min=a[i];
         if(min.getBonus()<a[i].getBonus())
             max=a[i];
     }
     result.setFirst(min);
     result.setSecond(max);
 }

　　直观的讲，带有超类型限定的通配符可以向泛型对象写入，带有子类型限定的通配符可以从泛型对象读取

---

　　

　　　　下面定义一个类扩展了comparable接口

 class getMax implements Comparable<Integer>{

     @Override
     public int compareTo(Integer o) {
         // TODO Auto-generated method stub
         return 0;
     }

 }

　　　　可以观察到Comparable接口本身就是一个泛型类型，实现后会重写compareTo方法。

　　　  现在可以给出一个泛型max限定方法

　　　　

public static <T extends Comparable> T max(..)

　　　

 public class MyGenerics {
     public static void main(String[] args) {
         Integer[] nums=new Integer[]{10,8};
         System.out.println(max(nums));
     }
     public static <T extends Comparable> T max(T[] a){
         if(a[0].compareTo(a[1])>0)
             return a[0];
         else
             return a[1];

     }
 }

 //output:10
但是compareTo方法下会标黄，提示
Type safety: The method compareTo(Object) belongs to the raw type Comparable.
 References to generic type Comparable<T> should be parameterized
大意就是类型安全什么的，因为comparable接口已经是泛型接口comparable<T>限定了比较的类型

public static <T extends Comparable<T>> T max(..)
//所以最好采用这种形式

　　

---

　　比较难理解的就是

public static <T extends Comparable<? super T>> T max(...)

　　与上文比较主要是有<T>与<? super T>的区别，文章的开头已经清楚 ? super T 意思是所有T的超类都是可以的。

　　现在可以把T换成Manager类

public static <Manager extends Comparable<? super Manager>>  Manager max(...)

　　如果没有 ? super 的话，上面的方法只能对Manager类进行操作，但是有个超类型限定，Emoployee也可以使用这个方法。