首页 > 代码库 > Java泛型解析(02):通配符限定

Java泛型解析(02):通配符限定

Java泛型解析(02):通配符限定

     考虑一个这样的场景,计算数组中的最大元素。
[code01]
     public class ArrayUtil {
           public static <T> T max(T[] array) {
                    if (array == null || 0 == array.length) { return null ;}
                   T max = array[0];
                    for (int i = 1; i < array.length; i++) {
                              if (max.compareTo(array[i]) < 0) {max = array[i];}
                   }
                    return max;
          }
     }
     仔细看看code01里面的代码(代码不完整),使用类型参数T定义一个max局部变量,这几意味着这个max可以是任意的类型,那么max.compareTo(array[i]) 方法的调用的前提是T所属的类中有compareTo方法,怎么能做到这一点呢?别着急,让我们来看看如何给类型参数进行限定,现在来对code01中的代码进行完善。
[code02]
     public class ArrayUtil {
           public static <T extends Comparable<T>> T max(T[] array) {
                    if (array == null || 0 == array.length) { return null ;}
                   T max = array[0];
                    for (int i = 1; i < array.length; i++) {
                              if (max.compareTo(array[i]) < 0) {max = array[i];}
                   }
                    return max;
          }
     }
     注意看,我们定义类型参数的变化:<T extends Comparable<T>>,这里将T类型限定在Comparable及其所有的子类。是不是很好奇Comparable明明是一个interfacce,根据所学知识判断,实现interface用的关键字是implements,为什么呢?
     <T extends Bounding Type>,表示T类型应该是绑定类型及其子类型(subType),T和绑定类型可以是类或者接口,使用extends关键字因为它更接近于子类的概念,另外Java设计者并不打算为Java添加新的关键字如:sub
     如果给T限定多个类型,则需要使用符号"&",如下面格式
[code03]
     <T extends Runnable & Serializable>
     细心的读者可能会发现,这里限定的都是interface,如果限定为class是不是也这么自由的呢?先不急着回答这个问题,我们知道Java中可以实现多个接口,而继承只能是单继承,可想而知,当我们给T限定类型的时候,限定为某个class的时候是有限制的,看看下面几组泛型限定的代码
[code04]
     <T extends Runnable & Serializable & ArrayList> // 错误
     <T extends Runnable & ArrayList & Serializable> // 错误
     <T extends ArrayList & LinkedList & Serializable> // 错误
     <T extends ArrayList & Runnable& Serializable> // 正确
     不难看出,如果要限定T为class的时候,就有一个非常严格的规则,这个class只能放在第一个,最多只能有一个class。其实很容易理解,这样一来,就能够严格控制T类型是单继承的,遵循Java的规范。
小结:
     1.类型限定只能限定某个类型及其子类,使用关键字extends。
     2.多个类型参数用","隔开,如:<K, V>,多个限定类型用"&"隔开,如: <T extends Runnable & Serializable>
     3.限定interface的时候,对interface的个数和顺序无严格要求,限定class时,则需要将class类型置于第一个,且最多只能存在一个class类型。
钻牛角尖:
     问:类型限定中可以通过 extends 来限定子类型,是否可以通过类似super关键字来限定超类型呢? 
    答:哈哈,问的好,接下来一一揭晓。
    比较遗憾的是,类似<T extends Runnable & Serializable>这样的泛型限定子类的语法,来限定超类是没有成为Java中的一个语法规范的,例如:
[code05]
     <T super File & Runnable> // 错误
     code03中的类型参数的定义是错误的,至少目前Java中没有这样的规范来支撑这种语法,如何解释这个问题,笔者得花一番心思了...
不得不请教面向对象先生了:
     1.面向接口(抽象)编程,而非面向实现编程。这个设计原则告诉我们,方法调用通过高层的抽象类或者接口来进行,具体调用的方法体就是我们实际运行时期传递的具体实现类的实例,这也是多态的一种体现。我们实现自己的泛型是提供后期应用程序员使用的,限定一个子类,这就需要我们通过子类来调用方法,而调用的方法体则是这个类的超类的实例,继承结构越往上就可能是abstract的,或者是interface,抽象类和接口是无法实例化对象,这种反设计让调用面临失败,一旦限定的这个类就是抽象的或者是接口,必定会造成这个泛型类或泛型方法无法使用,导致设计失败。举个例子:
[code06]
     public static <T super Runnable> void test(T runner) {
          runner.run();
     }
     这个T类型限定为Runnable的超类,这个Runnable是一个接口,无法实例化对象,方法参数runner就是一个不存在的实例,所以这是一个失败的设计,而且这种语法也无法通过编译器。
     面向对象先生的解释对初学者可能有点晦涩难懂,没关系,这里只要知道Java是不能支持这种泛型限定的。无论从设计角度,还是从后期扩展的角度,都是说不过去的。
     但是不能这样定义泛型,并不代表Java泛型中就没有 super 关键字了,接下来说说泛型中的通配符类型,有了前面的基础,这里恐怕不是问题了。
通配符类型
     通配符类型,相比于固定的泛型类型,它是一个巧妙的解决方案。如:
[code07]
     Couple<? extends Employee>
     表示Couple的泛型类型是Employee或者其子类,Couple<Manager>满足,而Couple<File>不满足了。通配符用 "?" 表示。
     我们来打印一下夫妇类中的wife:
[code08]
     public static void printWife(Couple<Employee> couple) {
          Employee wife = couple.getWife();
               System. out.println(wife);
     }
     code08中的方法参数只能将Employee组成的夫妇传入,貌似经理的如Couple<Manager>就不能了,这有点不合适了,搞得好像Manager还不能结婚了。所以要想让Manager也能结婚并打印其wife,需要更改我们的设计了:
[code09]
     public static void printWife(Couple<? extends Employee> couple) {
          Employee wife = couple.getWife();
               System. out .println(wife);
     }
     通配符的子类型限定的语法与文章一开始介绍的类型限定有点相似,但是这里有些细节的秘密。
[code10]
     public static <T extends Comparable<T>> T max(T[] array) {...}
     public static void printWife(Couple<? extends Employee> couple) {...}
     前者T是预定义的类型参数,T可以作为一个具体的类型来定义方法的参数类型,局部变量等,T的作用域是整个方法(方法返回值,参数,方法体中局部变量),这种设计是为了给使用者带来方便,将参数类型的指定权有限制地交给了使用者。而后者中不存在类型参数的定义,max方法参数的类型是预先定义好的Couple类型,使用者无法在使用的时候指定其他类型,但可以有限制地指定Couple中的泛型参数的类型,
     ? extends Employee 自身不能单独使用,可以理解为只能寄生在其他泛型类中,作为泛型类一个具体的类型参数,通常用于定义阶段,如下面:
[code11]
     public static ? extends Employee printWife() {...} // 错误
     public static void printWife(? extends Empoyee employee) {...} // 错误
     使用通配符来定义方法返回值和方法的参数类型在Java中是不允许的!
     弄清楚了前面类型限定和通配符的区别以后,再引入通配符的超类型限定就不是那么难以理解了。
通配符的超类型限定:
     和前面子类型的限定一样,用"?"表示通配符,它的存在必须存在泛型类的类型参数中,如:
[code12]
     Couple<? super Manager>
     格式跟通配符限定子类型一样,用了关键字super,但是这两种方式的通配符存在一个隐蔽的区别,让我们来揭晓吧,先看看下面代码:
[code13]、
     Couple<Manager> couple = new Couple<Manager>(new Manager(),new Manager());
     Couple<? extends Employee> couple2 = couple;
     Employee wife = couple2.getWife();
     // couple2.setWife(new Manager()); // 此处编译错误
     Couple<? extends Employee>定义了couple2后可以将getWife和setWife想象成如下:
[code14]
     ? extends Employee getWife() {...}
     void setWife(? extends Employee) {...}
     getWife是可以通过的,因为将一个返回值的引用赋给超类Employee是完全可以的,而setWife方法接受的是一个Employee的子类,具体是什么子类,编译器并不知道,拒绝传递任何特定的类型,所以couple2.setWife(new Manager())是不能被调用的。所以通配符的子类限定适用于读取。
     在来看看通配符的超类型限定,即Couple<? super Manager>,getWife和setWife可以想象成:
[code15]
     ? super Manager getWife() {...}
     void setWife(? super Manager) {...}
     getWife方法的返回值是Manager的超类型,而Manger的超类型是得不到保证的,虚拟器会将它会给Object,而setWife方法是需要的是Manager的超类型,所以传入任意Manager都是允许的,所以通配符的超类型限定适用于写入。
无限定通配符
     无限定通配符去除了超类型和子类型的规则,仅仅用一个"?"表示,并且也只能用于指定泛型类的类型参数中。如Couple<?>的形式,此时getWife和setWife方法如:
[code16]
     ? getWife() {...}
     void setWife(?) {...}
     getWife返回值直接付给了Object,而setWife方法是不允许调用的。那么既然这么脆弱,牛逼的Java设计者为什么还要引入这种通配符呢?在一些简单的操作中,五限定通配符还是有用武之地的,比如:
[code17]
     public static boolean isCoupleComplete(Couple<?> couple) {
          return couple.getWife() != null && couple.getHusband() != null;
      }
     这个方法体中,getWife和getHusband返回值都是Object类型的,此时我们只需要判断是否为null即可,而不需要知道具体的类型是什么,这就发挥了无限定通配符的作用了。发动脑经想一想,这个方法用文章开始所提到类型限定是否可以代替呢?自我思考中...
[code18]
     public static <T> boolean isCoupleComplete(Couple<T> couple) {
          return couple.getWife() != null && couple.getHusband() != null ;
      }
     public static <T extends Employee> boolean isCoupleComplete(Couple<T> couple) {
          return couple.getWife() != null && couple.getHusband() != null ;
     }
     到这里,爱思考的读者可能在思考一个问题,通配符代表了泛型类中的参数类型,在方法体中,怎么去捕获这个参数类型呢?这里考虑三种通配符的捕获
     1.Couple<? extends Employee> couple:getWife返回Employee
     2.Couple<? super Manager> couple:无法捕获,getWife返回Object
     3.Couple<?> couple:无法捕获,getWife返回Object
     悲催了,只有第一种能捕获,怎么办呢?别着急,看看下面的小魔术:
[code19]
     public static void print(Couple<?> couple) {
           printHelp(couple);
     }
     public static <T> void printHelp(Couple<T> couple) {
          T husband = couple.getHusband();
          T wife = couple.getWife();
          couple.setHusband(wife);
          couple.setWife(husband);
          System. out.println(husband);
          System. out.println(wife);
      }
     当需要捕获通配符的时候,可以借助前面所学的类型参数进行辅助,其实这是一个多余的动作,基本上用不到这么麻烦,这么做是为了把通配符和泛型限定联系起来,巩固一下之前的学习。
总结:
     1.泛型参数的限定,使用extends关键字,限定多个类型时用"&"隔开。如:<T extends RunnableSerializable> 
     2.泛型参数限定中,如果限定的类型是class而不是interface,则class必须放在限定类表中的第一个,且最多只能存在一个class。如:<T extends ArrayList & RunnableSerializable> 
     3.通配符只能用在泛型类的泛型参数中,不能单独使用。如Couple<?>、Couple<? extends Employee> 、Couple<? super Manager>
     4.通配符的超类型限定适用于写入,通配符的子类型限定适用于读取,无限定通配符适用于一些非null判断等简单操作。
     5.通配符的捕获可以借助泛型类型限定来辅助。
     这一节内容比较多,需要花点时间好好消化,体会总结中的5点,下一节,说一个深刻点的话题,虚拟机中的针对泛型代码的擦除。
Java泛型解析(01):认识泛型
Java泛型解析(02):通配符限定

Java泛型解析(02):通配符限定