Эккель Брюс
Шрифт:
public static void main(String[] args) { Solid<Bounded> solid =
new Solid<Bounded>(new BoundedO); solid.colorO; solid.getYO. solid.weightO;
}
} ///
Вероятно, вы заметили, что пример BasicBounds.java содержат некоторую избыточность, которая может быть устранена посредством наследования. С каждым уровнем наследования добавляются новые ограничения:
II: generics/InheritBounds.java
class HoldItem<T> { T item;
HoldItem(T item) { this.item = item; } T getltemO { return item; }
}
class Colored2<T extends HasColor> extends HoldItem<T> {
Colored2(T item) { super(item). }
java awt Color col or О { return item.getColorO; }
}
class ColoredDimension2<T extends Dimension & HasColor> extends Colored2<T> {
ColoredDimension2(T item) { super(item); } int getXO { return item x; } int getYO { return item.y, } int getZO { return item z; }
}
class Solid2<T extends Dimension & HasColor & Weight> extends ColoredDimension2<T> {
Solid2(T item) { super(item); } int weight О { return item.weightO; }
}
public class InheritBounds {
public static void main(String[] args) { Solid2<Bounded> solid2 =
new Solid2<Bounded>(new BoundedO); solid2 colorO: solid2 getYO; solid2 weightO,
}
} ///.-
Holdltem просто хранит объект; это поведение наследуется классом Colored2, который также требует, чтобы его параметр реализовывал HasColor. ColoredDi-mension2 и Solid2 продолжают расширение иерархии и добавляют на каждом уровне новые ограничения. Теперь методы наследуются, и их не нужно повторять в каждом классе.
Пример с большим количеством уровней:
//: generics/EpicBattlе.java // Demonstrating bounds in Java generics, import java util.*;
interface Superpower {} interface XRayVision extends Superpower { void seeThroughWallsO;
}
interface SuperHearing extends Superpower { void hearSubtleNoisesO;
}
interface SuperSmell extends Superpower { void trackBySmellO;
}
class SuperHero<POWER extends SuperPower> { POWER power;
SuperHero(POWER power) { this.power = power; } POWER getPower0 { return power; }
}
class SuperSleuth<POWER extends XRayVision>
extends SuperHero<POWER> {
SuperSleuth(POWER power) { super(power); } void see { power. seeThroughWallsO: }
}
class CanineHero<POWER extends SuperHearing & SuperSmell> extends SuperHero<POWER> {
CanineHero(POWER power) { super(power); } void hearO { power.hearSubtleNoisesO; } void smell О { power.trackBySmell0; }
}
class SuperHearSmell implements SuperHearing, SuperSmell { public void hearSubtleNoisesO {} public void trackBySmell0 {}
}
class DogBoy extends CanineHero<SuperHearSmell> { DogBoyO { super(new SuperHearSmell0); }
}
public class EpicBattle {
// Ограничения в параметризованных методах: static <POWER extends SuperHearing> void useSuperHearing(SuperHero<POWER> hero) { hero, get Power hearSubtleNoisesO:
}
static <POWER extends SuperHearing & SuperSmell> void superFind(SuperHero<POWER> hero) {
hero, get Power 0 .hearSubtleNoisesO; hero.getPower .trackBySmel 10;
}
public static void main(String[] args) { DogBoy dogBoy = new DogBoyO; useSuperHearing(dogBoy); superFind(dogBoy); // Так можно:
List<? extends SuperHearing> audioBoys; // А так нельзя:
// List<? extends SuperHearing & SuperSmell> dogBoys;
}
} ///:-
Метасимволы
Мы уже встречали простые примеры использования метасимволов — вопросительных знаков в выражениях аргументов параметризации — в главах И и 13. В этом разделе тема будет рассмотрена более подробно.
Начнем с примера, демонстрирующего одну особенность массивов: массив производного типа можно присвоить ссылке на массив базового типа:
II: generics/CovariantArrays.java class Fruit {}
class Apple extends Fruit {}
class Jonathan extends Apple {} class Orange extends Fruit {}
public class CovariantArrays {
public static void main(String[] args) { Fruit[] fruit = new Apple[10]; fruit[0] = new AppleO; // OK fruit[l] = new JonathanO; // OK
// Тип времени выполнения - Applet], а не Fruit[] или Orange[]: try {