邊界 · 《Java 編程思想》第五版

## 邊界 *邊界*（bounds）在本章的前面進行了簡要介紹。邊界允許我們對泛型使用的參數類型施加約束。盡管這可以強制執行有關應用了泛型類型的規則，但潛在的更重要的效果是我們可以在綁定的類型中調用方法。由于擦除會刪除類型信息，因此唯一可用于無限制泛型參數的方法是那些 **Object** 可用的方法。但是，如果將該參數限制為某類型的子集，則可以調用該子集中的方法。為了應用約束，Java 泛型使用了 `extends` 關鍵字。重要的是要理解，當用于限定泛型類型時，`extends` 的含義與通常的意義截然不同。此示例展示邊界的基礎應用： ```java // generics/BasicBounds.java interface HasColor { java.awt.Color getColor(); } class WithColor<T extends HasColor> { T item; WithColor(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 Coord { public int x, y, z; } // This fails. Class must be first, then interfaces: // class WithColorCoord<T extends HasColor & Coord> { // Multiple bounds: class WithColorCoord<T extends Coord & HasColor> { T item; WithColorCoord(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 Coord & 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 Coord implements HasColor, Weight { @Override public java.awt.Color getColor() { return null; } @Override public int weight() { return 0; } } public class BasicBounds { public static void main(String[] args) { Solid<Bounded> solid = new Solid<>(new Bounded()); solid.color(); solid.getY(); solid.weight(); } } ``` 你可能會觀察到 **BasicBounds.java** 中似乎包含一些冗余，它們可以通過繼承來消除。在這里，每個繼承級別還添加了邊界約束： ```java // generics/InheritBounds.java class HoldItem<T> { T item; HoldItem(T item) { this.item = item; } T getItem() { return item; } } class WithColor2<T extends HasColor> extends HoldItem<T> { WithColor2(T item) { super(item); } java.awt.Color color() { return item.getColor(); } } class WithColorCoord2<T extends Coord & HasColor> extends WithColor2<T> { WithColorCoord2(T item) { super(item); } int getX() { return item.x; } int getY() { return item.y; } int getZ() { return item.z; } } class Solid2<T extends Coord & HasColor & Weight> extends WithColorCoord2<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<>(new Bounded()); solid2.color(); solid2.getY(); solid2.weight(); } } ``` **HoldItem** 擁有一個對象，因此此行為將繼承到 **WithColor2** 中，這也需要其參數符合 **HasColor**。 **WithColorCoord2** 和 **Solid2** 進一步擴展了層次結構，并在每個級別添加了邊界。現在，這些方法已被繼承，并且在每個類中不再重復。這是一個具有更多層次的示例： ```java // generics/EpicBattle.java // Bounds in Java generics import java.util.List; 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 { @Override public void hearSubtleNoises() { } @Override public void trackBySmell() { } } class DogPerson extends CanineHero<SuperHearSmell> { DogPerson() { 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) { DogPerson dogPerson = new DogPerson(); useSuperHearing(dogPerson); superFind(dogPerson); // You can do this: List<? extends SuperHearing> audioPeople; // But you can't do this: // List<? extends SuperHearing & SuperSmell> dogPs; } } ``` 接下來將要研究的通配符將會把范圍限制在單個類型。