泛型中的边界与通配符

边界可以强制规定泛型可以应用的类型，更重要的是你可以将这个类型参数限制为某个类型子集，这样就可以调用这些类型的方法。

interface HasColor{ java.awt.Color getColor();}
class Dimension { public int x,y,z;}
//多边界，按类在前，接口在后的顺序
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();}
//采用继承来简化代码
class HoldItem<T>{
  T item;
  HoldItem(T item) { this.item=item;}
  T getItem() {return item;}
}
//让Colored2通过继承HoldItem，获得持有一个对象的能力
class Colored2<T extends HasColor> extends HoldItem<T> {
  Colored2(T item) { super(item);}
  java.awt.Color color() { return item.getColor();}
class ColoredDimension2<T extends Dimension & Weight> extends Colored2<T> {
  ColoredDimension2(T item) { super(item);}
  int getX() {return item.x;}
  int getY() {return item.y;}
  int getZ() {return item.z;}
}
class Cube<T extends Dimension & HasColor & Weight> extends ColorDimension2<T> {
  Cube(T item) { super(item);}
  int weight() { return item.weight();}
}

对泛型方法应用边界

interface SuperPower {}
interface SuperHearing extends SuperPower {
  void hearSubtleNoises();
}

class SuperHero<POWER extends SuperPower> {
  POWER power;
  SuperHero(POWER power) { this.power=power;}
  POWER getPower() { return power;}
}

public class EpicBattel {
  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);
  }
}