泛型中? super T和? extends T的区别与理解

经常发现有List、Set的声明,是什么意思呢?表示包括T在内的任何T的父类,表示包括T在内的任何T的子类,下面我们详细分析一下两种通配符具体的区别。

 

extends

List foo3的通配符声明,意味着以下的赋值是合法的:

01 // Number "extends" Number (in this context)
02  
03 Listextends Number> foo3 = new ArrayListextends Number>();
04  
05 // Integer extends Number
06  
07 Listextends Number> foo3 = new ArrayListextends Integer>();
08  
09 // Double extends Number
10  
11 Listextends Number> foo3 = new ArrayListextends Double>();
  1. 读取操作通过以上给定的赋值语句,你一定能从foo3列表中读取到的元素的类型是什么呢?你可以读取到Number,因为以上的列表要么包含Number元素,要么包含Number的类元素。

    你不能保证读取到Integer,因为foo3可能指向的是List

    你不能保证读取到Double,因为foo3可能指向的是List

  2. 写入操作过以上给定的赋值语句,你能把一个什么类型的元素合法地插入到foo3中呢?

    你不能插入一个Integer元素,因为foo3可能指向List

    你不能插入一个Double元素,因为foo3可能指向List

    你不能插入一个Number元素,因为foo3可能指向List

    你不能往List中插入任何类型的对象,因为你不能保证列表实际指向的类型是什么,你并不能保证列表中实际存储什么类型的对象。唯一可以保证的是,你可以从中读取到T或者T的子类。

super

现在考虑一下List

List foo3的通配符声明,意味着以下赋值是合法的:

01 // Integer is a "superclass" of Integer (in this context)
02  
03 Listsuper Integer> foo3 = new ArrayList();
04  
05 // Number is a superclass of Integer
06  
07 Listsuper Integer> foo3 = new ArrayList();
08  
09 // Object is a superclass of Integer
10  
11 Listsuper Integer> foo3 = new ArrayList();
  1. 读取操作通过以上给定的赋值语句,你一定能从foo3列表中读取到的元素的类型是什么呢?你不能保证读取到Integer,因为foo3可能指向List或者List

    你不能保证读取到Number,因为foo3可能指向List

    唯一可以保证的是,你可以读取到Object或者Object子类的对象(你并不知道具体的子类是什么)。

  2. 写入操作通过以上给定的赋值语句,你能把一个什么类型的元素合法地插入到foo3中呢?你可以插入Integer对象,因为上述声明的列表都支持Integer。

    你可以插入Integer的子类的对象,因为Integer的子类同时也是Integer,原因同上。

    你不能插入Double对象,因为foo3可能指向ArrayList

    你不能插入Number对象,因为foo3可能指向ArrayList

    你不能插入Object对象,因为foo3可能指向ArrayList

  3. PECS

    请记住PECS原则:生产者(Producer)使用extends,消费者(Consumer)使用super。

    • 生产者使用extends

    如果你需要一个列表提供T类型的元素(即你想从列表中读取T类型的元素),你需要把这个列表声明成,比如List,因此你不能往该列表中添加任何元素。

    • 消费者使用super

    如果需要一个列表使用T类型的元素(即你想把T类型的元素加入到列表中),你需要把这个列表声明成,比如List,因此你不能保证从中读取到的元素的类型。

    • 即是生产者,也是消费者

    如果一个列表即要生产,又要消费,你不能使用泛型通配符声明列表,比如List

    例子

    请参考java.util.Collections里的copy方法(JDK1.7):

    泛型中? super T和? extends T的区别与理解_第1张图片

     

    引用例子:

     

    泛型中使用通配符有两种形式:子类型限定和超类型限定

    (1)子类型限定

    下面的代码定义了一个Pair类,以及Employee,Manager和President类。

     

    1. public class Pair {  
    2.     private T first;  
    3.     private T second;  
    4.   
    5.     public Pair(T first, T second) {  
    6.         this.first = first;  
    7.         this.second = second;  
    8.     }  
    9.   
    10.     public T getFirst() {  
    11.         return first;  
    12.     }  
    13.   
    14.     public T getSecond() {  
    15.         return second;  
    16.     }  
    17.   
    18.     public void setFirst(T newValue) {  
    19.         first = newValue;  
    20.     }  
    21.   
    22.     public void setSecond(T newValue) {  
    23.         second = newValue;  
    24.     }  
    25. }  
    26.   
    27. class Employee {  
    28.     private String name;  
    29.     private double salary;  
    30.       
    31.     public Employee(String n, double s) {  
    32.         name = n;  
    33.         salary = s;  
    34.     }  
    35.       
    36.     public String getName() {  
    37.         return name;  
    38.     }  
    39.   
    40.     public double getSalary() {  
    41.         return salary;  
    42.     }  
    43. }  
    44.   
    45. class Manager extends Employee {  
    46.     public Manager(String n, double s) {  
    47.         super(n, s);  
    48.     }  
    49. }  
    50.   
    51. class President extends Manager {  
    52.     public President(String n, double s) {  
    53.         super(n, s);  
    54.     }  
    55. }  

     

     
     

    现在要定义一个函数可以打印Pair


     

    1. public static void printEmployeeBoddies(Pair pair) {  
    2.     System.out.println(pair.getFirst().getName() + ":" + pair.getSecond().getName());  
    3. }  

    可是有一个问题是这个函数输入参数只能传递类型Pair,而不能传递Pair和Pair。例如下面的代码会产生编译错误

     

    1. Manager mgr1 = new Manager("Jack", 10000.99);  
    2. Manager mgr2 = new Manager("Tom", 10001.01);  
    3. Pair managerPair = new Pair(mgr1, mgr2);  
    4. PairAlg.printEmployeeBoddies(managerPair);  

    之所以会产生编译错误,是因为Pair和Pair实际上是两种类型。

    由上图可以看出,类型Pair是类型Pair的子类型,所以为了解决这个问题可以把函数定义改成
    public static void printEmployeeBoddies(Pair pair)

    但是使用通配符会不会导致通过Pair的引用破坏Pair对象呢?例如:
    Pair employeePair = managePair;employeePair.setFirst(new Employee("Tony", 100));
    不用担心,编译器会产生一个编译错误。Pair参数替换后,我们得到如下代码
    ? extends Employee getFirst()
    void setFirst(? extends Employee)
    对于get方法,没问题,因为编译器知道可以把返回对象转换为一个Employee类型。但是对于set方法,编译器无法知道具体的类型,所以会拒绝这个调用。

    (2)超类型限定

    超类型限定和子类型限定相反,可以给方法提供参数,但是不能使用返回值。? super Manager这个类型限定为Manager的所有超类。

    Pair参数替换后,得到如下方法

    ? super Manager getFirst()
    void setFirst(? super Manager)

    编译器可以用Manager的超类型,例如Employee,Object来调用setFirst方法,但是无法调用getFirst,因为不能把Manager的超类引用转换为Manager引用。

    超类型限定的存在是为了解决下面一类的问题。例如要写一个函数从Manager[]中找出工资最高和最低的两个,放在一个Pair中返回。

     

    1. public static void minMaxSal(Manager[] mgrs, Pair pair) {  
    2.     if (mgrs == null || mgrs.length == 0) {  
    3.         return;  
    4.     }  
    5.       
    6.     pair.setFirst(mgrs[0]);  
    7.     pair.setSecond(mgrs[0]);  
    8.     //TODO  
    9. }  

    如此就可以这样调用

     

      1. Pair pair = new Pair(null, null);  
      2. minMaxSal(new Manager[] {mgr1, mgr2}, pair);  

     

    你可能感兴趣的:(泛型)