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用的keyword是implements,为什么呢?
     <T extends Bounding Type>,表示T类型应该是绑定类型及其子类型(subType),T和绑定类型能够是类或者接口,使用extendskeyword由于它更接近于子类的概念,另外Java设计者并不打算为Java加入新的keyword如: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。事实上非常easy理解,这样一来。就行严格控制T类型是单继承的,遵循Java的规范。
小结:
     1.类型限定仅仅能限定某个类型及其子类。使用keywordextends。
     2.多个类型參数用","隔开。如:<K, V>,多个限定类型用"&"隔开。如: <T extends Runnable & Serializable>
     3.限定interface的时候。对interface的个数和顺序无严格要求,限定class时。则须要将class类型置于第一个,且最多仅仅能存在一个class类型。
钻牛角尖:
     问:类型限定中能够通过 extends 来限定子类型,能否够通过类似superkeyword来限定超类型呢? 
    答:哈哈。问的好。接下来一一揭晓。
    比較遗憾的是,类似<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 keyword了,接下来说说泛型中的通配符类型。有了前面的基础。这里恐怕不是问题了。
通配符类型
     通配符类型,相比于固定的泛型类型,它是一个巧妙的解决方式。如:
[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>
     格式跟通配符限定子类型一样。用了keywordsuper,可是这两种方式的通配符存在一个隐蔽的差别,让我们来揭晓吧,先看看以下代码:
[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.泛型參数的限定,使用extendskeyword,限定多个类型时用"&"隔开。如:<T extends Runnable& Serializable> 
     2.泛型參数限定中,假设限定的类型是class而不是interface,则class必须放在限定类表中的第一个,且最多仅仅能存在一个class。如:<T extends ArrayList & Runnable& Serializable> 
     3.通配符仅仅能用在泛型类的泛型參数中,不能单独使用。

如Couple<?

>、Couple<? extends Employee> 、Couple<? super Manager>

     4.通配符的超类型限定适用于写入,通配符的子类型限定适用于读取,无限定通配符适用于一些非null推断等简单操作。

     5.通配符的捕获能够借助泛型类型限定来辅助。
     这一节内容比較多,须要花点时间好好消化,体会总结中的5点。下一节,说一个深刻点的话题,虚拟机中的针对泛型代码的擦除。



Java泛型解析(04):约束和局限性

=====【感谢亲阅读寻常心的文章,亲若认为此文有帮助,顶一顶亲的支持将给我前进的动力】=====

转载于:https://www.cnblogs.com/zhchoutai/p/7263722.html

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值