Java泛型 extends关键字设置边界

约定不等于承诺〃 2024-04-19 00:43 5阅读 0赞

本文主要介绍在**泛型定义中的`< >`中的占位符如何配合extends关键字使用**，形如`<T extends Integer>`。泛型定义存在于这三种形式中：泛型类、泛型接口、泛型方法。

*  **一般的泛型定义中的`<T>`，相当于`<T extends Object>`，而类型擦除则会将类型参数擦除成T的上界，即Object。则在泛型定义中作为`T`类型的对象可以调用Object的函数和属性。**
 *  **使用了extends的泛型定义中的`<T extends Integer>`，其上界已被明显定义了，此时会将类型参数擦除成Integer。则在泛型定义中作为`T`类型的对象可以调用Integer的函数和属性。**

接下来本文将以几个示例和具体分析来讲解剩下的知识点。

# 类型参数多边界的分析 #

此例中的泛型类，类型参数带有多个边界。讲下类的实际意义：Dimension代表物体的方位、HasColor代表物体的颜色、Weight代表物体的重量。

interface HasColor {  java.awt.Color getColor(); }
    
    class Colored<T extends HasColor> { 
        T item;
        Colored(T item) {  this.item = item; }
        T getItem() {  return item; }
        // The bound allows you to call a method:
        java.awt.Color color() {  return item.getColor(); }
    }
    
    class Dimension {  public int x, y, z; }
    
    // This won't work -- class must be first, then interfaces:
    // class ColoredDimension<T extends HasColor & Dimension> { }
    
    // Multiple bounds:
    class ColoredDimension<T extends Dimension & HasColor> { 
        T item;
        ColoredDimension(T item) {  this.item = item; }
        T getItem() {  return item; }
        java.awt.Color color() {  return item.getColor(); }
        int getX() {  return item.x; }
        int getY() {  return item.y; }
        int getZ() {  return item.z; }
    }
    
    interface Weight {  int weight(); }
    
    // As with inheritance, you can have only one
    // concrete class but multiple interfaces:
    class Solid<T extends Dimension & HasColor & Weight> { 
        T item;
        Solid(T item) {  this.item = item; }
        T getItem() {  return item; }
        java.awt.Color color() {  return item.getColor(); }
        int getX() {  return item.x; }
        int getY() {  return item.y; }
        int getZ() {  return item.z; }
        int weight() {  return item.weight(); }
    }
    
    class Bounded extends Dimension implements HasColor, Weight { 
        public java.awt.Color getColor() {  return null; }
        public int weight() {  return 0; }
    }
    
    public class BasicBounds { 
        public static void main(String[] args) { 
            Solid<Bounded> solid = new Solid<Bounded>(new Bounded());
            solid.color();
            solid.getY();
            solid.weight();
        }
    } ///:~

*  `class Colored<T extends HasColor>`这个泛型类的泛型定义中，要求了类型参数T的边界为`HasColor`，正因如此，在函数`java.awt.Color color() { return item.getColor(); }`中便可以通过一个T类型的变量item来调用属于HasColor的方法。
 *  `class ColoredDimension<T extends HasColor & Dimension> { }`，此时定义了边界同时为`HasColor & Dimension`，但是由于**编译器要求占位符后的extends后第一个必须是类，之后的必须是接口（这就和正常的类的继承规则一样）**，所以此句通不过编译。而`class ColoredDimension<T extends Dimension & HasColor>`给出了正确的定义，即第一个必须是类，之后的必须是接口。
 *  `class ColoredDimension<T extends Dimension & HasColor>`的类定义中，因为T的边界是`HasColor & Dimension`，所以在类定义中，既可以获取Dimension的属性，也可以调用HasColor的方法。
 *  `class Solid<T extends Dimension & HasColor & Weight>`的类定义中，extends后第一个是类，之后的都是接口，符合刚才讲的规则。同理，也可以从这些边界中，获取属性，调用方法。
 *  `class Bounded extends Dimension implements HasColor, Weight`这个类将在生成泛型类对象，用来指定具体类型为Bounded。因为`class Solid<T extends Dimension & HasColor & Weight>`的类型参数T的要求是`extends Dimension & HasColor & Weight`，所以指定具体类型为`new Solid<Bounded>`，是可以的。因为类定义中构造器的声明为`Solid(T item)`，且具体类型为`new Solid<Bounded>`中指定的Bounded，所以要求构造器的实参为Bounded或者Bounded的子类。

class derivedBounded extends Bounded { }
    
    class Bounded1 extends Dimension implements HasColor, Weight { 
        public java.awt.Color getColor() {  return null; }
        public int weight() {  return 0; }
    }
    
    public class BasicBounds { 
        public static void main(String[] args) { 
            //Solid<Bounded> solid = new Solid<Integer>(new derivedBounded());//给定的具体类型不符合边界
            Solid<Bounded> solid1 = new Solid<Bounded>(new derivedBounded());//可以传递具体类型Bounded的子类
            //Solid<Bounded> solid2 = new Solid<Bounded>(new Bounded1());//编译报错，因为泛型的静态类型检查
            solid1.color();
            solid1.getY();
            solid1.weight();
        }
    } ///:~

*  根据上一条，那么`new Solid<Integer>(new Bounded())`这里指定的具体类型，由于和泛型类定义的T类型参数的要求`extends Dimension & HasColor & Weight`不相符，所以编译会报错；给构造器传值时，实参可以是Bounded的子类；一个同样继承了相同边界的类Bounded1 ，不能传递给构造器，因为类型已经被指定为Bounded了。

但是类型参数有多个边界时，java内部即java字节码到底是怎么处理的呢：

public static void main(java.lang.String[]);
        Code:
           0: new           #2                  // class Solid
           3: dup
           4: new           #3                  // class Bounded
           7: dup
           8: invokespecial #4                  // Method Bounded."<init>":()V
          11: invokespecial #5                  // Method Solid."<init>":(LDimension;)V
          14: astore_1

从`Method Solid."<init>":(LDimension;)V`可以看到，给Solid的构造器传递参数时，编译器认为这个形参是个Dimension，这就是**编译器处理多个边界的方法，永远处理为第一个边界，即类型擦除为第一个边界**。但剩下的两个边界怎么办呢，这里都被处理第一个边界了，我们再去看一下Solid.class的反编译代码就能找到答案：

// Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    
    import java.awt.Color;
    
    class Solid<T extends Dimension & HasColor & Weight> { 
        T item;
    
        Solid(T item) { 
            this.item = item;
        }
    
        T getItem() { 
            return this.item;
        }
    
        Color color() { 
            return ((HasColor)this.item).getColor();//类型转换为其他边界，再调用方法
        }
    
        int getX() { 
            return this.item.x;
        }
    
        int getY() { 
            return this.item.y;
        }
    
        int getZ() { 
            return this.item.z;
        }
    
        int weight() { 
            return ((Weight)this.item).weight();//类型转换为其他边界，再调用方法
        }
    }

**当调用的方法不属于第一个边界时，就进行类型转换处理为其他边界**就行，反正T肯定是符合`extends Dimension & HasColor & Weight`的。

# 继承有边界要求的泛型类 #

通过观察上例可知，Colored、ColoredDimension、Solid这三个类在持有对象的方面有冗余的地方：都有同一个成员变量、同一个构造器、同一个get函数。而类型参数上，边界也是依次叠加的。同样，对于这些边界所带来的属性和方法，也是冗余的。  
所以下例对其进行了修改，通过继承来消除冗余，注意，下面继承的泛型类对类型参数是有边界要求的：

//HoldItem对边界T没有要求
    class HoldItem<T> { 
        T item;
        HoldItem(T item) {  this.item = item; }
        T getItem() {  return item; }
    }
    //Colored2对边界T有HasColor的要求
    class Colored2<T extends HasColor> extends HoldItem<T> { 
        Colored2(T item) {  super(item); }
        java.awt.Color color() {  return item.getColor(); }
    }
    //ColoredDimension2对边界T有Dimension & HasColor的要求
    class ColoredDimension2<T extends Dimension & HasColor>
            extends Colored2<T> { 
        ColoredDimension2(T item) {   super(item); }
        int getX() {  return item.x; }
        int getY() {  return item.y; }
        int getZ() {  return item.z; }
    }
    //Solid2对边界T有Dimension & HasColor & Weight的要求，不过没有类继承它了
    class Solid2<T extends Dimension & HasColor & Weight>
            extends ColoredDimension2<T> { 
        Solid2(T item) {   super(item); }
        int weight() {  return item.weight(); }
    }
    
    public class InheritBounds { 
        public static void main(String[] args) { 
            Solid2<Bounded> solid2 =
                    new Solid2<Bounded>(new Bounded());
            solid2.color();
            solid2.getY();
            solid2.weight();
        }
    } ///:~

*  `HoldItem`这个泛型类通过类型参数T把成员变量、构造器、get函数都定义好了，之后的类通过继承它就可以获得这些属性和方法。
 *  `Colored2`泛型类继承了`HoldItem`，获得了后者的属性和方法从而减少了冗余。同时，`class Colored2<T extends HasColor>`属于“定义泛型类”，`extends HoldItem<T>`属于“使用泛型类”，使用泛型类需要指定具体类型，现在确定具体类型的任务延后到了`<T extends HasColor>`的确认。再从边界是否符合的情况分析，`HoldItem`的要求是`<T>`属于无边界，`<T extends HasColor>`这样的边界定义属于HasColor边界，从范围上说`<T extends HasColor>`是小于等于`<T>`的，这样是可以的。由于T添加了HasColor边界，所以可以调用`item.getColor()`方法了。
 *  `ColoredDimension2`泛型类继承了`Colored2`。从边界是否符合的情况分析，`Colored2`对T的边界要求是`<T extends HasColor>`，而`ColoredDimension2`定义中的T的边界是`<T extends Dimension & HasColor>`，`<T extends Dimension & HasColor>`小于等于`<T extends HasColor>`，符合要求。换句话说，`ColoredDimension2`定义中的T的边界必须比`Colored2`的边界要求一致，或者范围更小。
 *  `Solid2`泛型类继承了`ColoredDimension2`。从边界是否符合的情况分析，`<T extends Dimension & HasColor & Weight>`小于等于`ColoredDimension2`的边界要求`<T extends Dimension & HasColor>`，符合要求。

总结一下：

*  当一个泛型类继承另一个泛型类时（前者属于“定义泛型类”，后者属于“使用泛型类”），且使用了同一个类型参数时，定义泛型类的类型参数边界定义一定要小于等于使用的那个泛型类的边界要求。

# 泛型方法中的边界定义 #

**泛型方法中对类型参数的边界定义，同样也得符合使用的泛型类的边界要求**。此例中，泛型类同样继承别的泛型类，分析同上不赘述。讲下类的实际意义：一系列接口代表了超能力、一系列类代表了超级英雄，它们拥有一个超能力的成员变量。

import java.util.*;
    
    interface SuperPower { }
    interface XRayVision extends SuperPower { 
        void seeThroughWalls();
    }
    interface SuperHearing extends SuperPower { 
        void hearSubtleNoises();
    }
    interface SuperSmell extends SuperPower { 
        void trackBySmell();
    }
    
    class SuperHero<POWER extends SuperPower> { 
        POWER power;
        SuperHero(POWER power) {  this.power = power; }
        POWER getPower() {  return power; }
    }
    
    class SuperSleuth<POWER extends XRayVision> extends SuperHero<POWER> { 
        SuperSleuth(POWER power) {  super(power); }
        void see() {  power.seeThroughWalls(); }
    }
    
    class CanineHero<POWER extends SuperHearing & SuperSmell> extends SuperHero<POWER> { 
        CanineHero(POWER power) {  super(power); }
        void hear() {  power.hearSubtleNoises(); }
        void smell() {  power.trackBySmell(); }
    }
    
    class SuperHearSmell implements SuperHearing, SuperSmell { 
        public void hearSubtleNoises() { }
        public void trackBySmell() { }
    }
    
    class DogBoy extends CanineHero<SuperHearSmell> { 
        DogBoy() {  super(new SuperHearSmell()); }
    }
    
    public class EpicBattle { 
        // Bounds in generic methods:
        static <POWER extends SuperHearing>
        void useSuperHearing(SuperHero<POWER> hero) { //泛型方法
            hero.getPower().hearSubtleNoises();
        }
        static <POWER extends SuperHearing & SuperSmell>
        void superFind(SuperHero<POWER> hero) { //泛型方法
            hero.getPower().hearSubtleNoises();
            hero.getPower().trackBySmell();
        }
        public static void main(String[] args) { 
            DogBoy dogBoy = new DogBoy();
            useSuperHearing(dogBoy);
            superFind(dogBoy);
            // You can do this:
            List<? extends SuperHearing> audioBoys;
            // But you can't do this:
            // List<? extends SuperHearing & SuperSmell> dogBoys;
        }
    } ///:~

*  主函数中的`useSuperHearing`泛型方法中，其对T的边界定义为`<POWER extends SuperHearing>`。而在形参中使用了泛型类`SuperHero<POWER>`，其对边界的要求是`<POWER extends SuperPower>`。因为SuperHearing继承了SuperPower，所以边界定义符合了对边界的要求。
 *  主函数中的`useSuperHearing`泛型方法中，其对T的边界定义为`<POWER extends SuperHearing>`。正因如此，在方法中便可以调用SuperHearing的方法`hearSubtleNoises`了。

# 其他 #

本文例子均来自java编程思想，例子本身不错，但奈何作者对其做的讲解很少，所以本人为其加上了详细的分析。其实这些例子都需要反复琢磨，精读之后才会对泛型的extends关键字有深刻的理解。