java - 如何正确使用多重边界？

Question

我正在尝试创建一个实例化一个名为“MultipleBoundsClass”的通用类，它具有多个边界 - 一个名为“OrderedPair”的类和一个名为“Pair”的接口(interface)(由 Ordered Pair 实现)。

我尝试删除接口(interface)边界，这样我就可以编译了。但我不知道为什么会这样，也不知道我是如何在包含接口(interface)边界的情况下成功实现这一点的。

public interface Pair<K, V>
{
  public K getKey();
  public V getValue();
}

public class OrderedPair<K, V> implements Pair
{
  private K key;
  private V value;
  public OrderedPair(K key, V value)
  {
    this.key = key;
    this.value = value;
  }
  public K getKey()
  {
    return key;
  }
  public V getValue()
  {
    return value;
  }
}

class OrderedPair {}
interface Pair {}
public class MultipleBounds<T extends OrderedPair & Pair>
{
  private T t;
  public MultipleBounds(T t)
  {
    this.t = t;
  }
  public T getPair()
  {
    return t;
  }
}

public static void main(String[] args)
{
  OrderedPair<String, Integer> p1 = new OrderedPair<>("even", 8);
  MultipleBounds<OrderedPair> myPair = new MultipleBounds<OrderedPair>(p1);
}

我收到错误“类型参数 OrderedPair 不在类型变量 T 的范围内”。有界类型将泛型参数的参数限制为您定义的类及其子类，那么当接口(interface)作为当前边界包括在内时，为什么 OrderedPair 类型不在其自身边界内？

Answer 1

我想提供一个示例，说明您可能如何使用多个边界。这很奇怪，但可能有助于理解事物。

假设我们有一个容器，我们可以放入一些东西。

abstract class Container {
    private Object content;

    public void put(Object object) { this.content = object; }
    public Object get() { return content; }
}

然后，有一些接口(interface)可以为这些容器定义一些属性。它们可能是可滚动和/或易燃。

interface Rollable { void roll(); /* rolls somehow */ }
interface Inflammable { void burnItself(); /* burns somehow */ }

然后，我们定义具体的 Container 类:一个 CardboardBox、一个 GiftBox、一个 MetalBarrel 和一个 WoodBarrel，根据属性实现接口(interface):

class CardboardBox extends Container implements Inflammable {
    @Override
    public void burnItself() { /* omit implementation */ }
}

class GiftBox extends Container implements Rollable, Inflammable {
    @Override
    public void burnItself() { /* omit implementation */ }
    @Override
    public void roll() { /* omit implementation */ }
}

class MetalBarrel extends Container implements Rollable {
    @Override
    public void roll() { /* omit implementation */ }
}

class WoodBarrel extends Container implements Rollable, Inflammable {
    @Override
    public void burnItself() { /* omit implementation */ }
    @Override
    public void roll() { /* omit implementation */ }
}

现在，真正的离奇。假设您要创建一个 Stock，其中所有的东西都必须是 Rollable。和易燃。因为你想把你所有的容器都卷进去，并能够燃烧其中一个。您定义一个 Stock:

class Stock <T extends Container & Rollable & Inflammable> {
    private List<T> containers;

    void addContainer(T container) { containers.add(container); }

    void rollAllContainers() { containers.forEach(Rollable::roll); }

    void burnContainer(int index) { containers.get(index).burnItself(); }
}

然后您就可以创建其中一个。您不受限于 Container 类型；仅针对其属性 - 因为它们是由接口(interface)定义的。

public static void main(String[] args) {
    Stock<GiftBox> giftBoxStock = new Stock<>();

    GiftBox giftBox = new GiftBox();
    giftBox.put("a gift");
    GiftBox giftBox1 = new GiftBox();
    giftBox1.put("another gift");

    giftBoxStock.addContainer(giftBox);
    giftBoxStock.addContainer(giftBox1);
    giftBoxStock.rollAllContainers();
    giftBoxStock.burnContainer(0);

    Stock<WoodBarrel> woodBarrelStock = new Stock<>();

    WoodBarrel woodBarrel = new WoodBarrel();
    woodBarrel.put("wine");
    WoodBarrel woodBarrel1 = new WoodBarrel();
    woodBarrel1.put("gas");

    woodBarrelStock.addContainer(woodBarrel);
    woodBarrelStock.addContainer(woodBarrel1);
    woodBarrelStock.rollAllContainers();
    woodBarrelStock.burnContainer(1);
}