为什么在有界通配符泛型中不能有多个接口？

我知道Java的泛型类型有各种各样的违反直觉的属性。特别是我不理解的一个，希望有人能向我解释。为类或接口指定类型参数时，可以对其进行绑定，以使其必须使用来实现多个接口public class Foo<T extends InterfaceA & InterfaceB>。但是，如果要实例化实际对象，则此方法不再起作用。List<? extends InterfaceA>很好，但是List<? extends InterfaceA & InterfaceB>无法编译。考虑以下完整代码段：

import java.util.List;

public class Test {

  static interface A {
    public int getSomething();
  }

  static interface B {
    public int getSomethingElse();
  }

  static class AandB implements A, B {
    public int getSomething() { return 1; }
    public int getSomethingElse() { return 2; }
  }

  // Notice the multiple bounds here. This works.
  static class AandBList<T extends A & B> {
    List<T> list;

    public List<T> getList() { return list; }
  }

  public static void main(String [] args) {
    AandBList<AandB> foo = new AandBList<AandB>(); // This works fine!
    foo.getList().add(new AandB());
    List<? extends A> bar = new LinkedList<AandB>(); // This is fine too
    // This last one fails to compile!
    List<? extends A & B> foobar = new LinkedList<AandB>();
  }
}

似乎bar应该明确定义的语义-我想通过允许两种类型而不是一种类型的交集，不会丢失类型安全性。我敢肯定有一个解释。有谁知道它是什么？

有趣的是，接口java.lang.reflect.WildcardType看起来支持通配符arg的上限和下限。每个都可以包含多个边界

Type[] getUpperBounds();
Type[] getLowerBounds();

这超出了语言允许的范围。源代码中有一个隐藏的注释

// one or many? Up to language spec; currently only one, but this API
// allows for generalization.

接口的作者似乎认为这是偶然的限制。

您问题的罐头答案是，泛型本身已经太复杂了；增加更多的复杂性可能被证明是最后一根稻草。

为了使通配符具有多个上限，必须通读规范并确保整个系统仍然有效。

我知道的一个麻烦是类型推断。当前的推理规则根本无法处理交集类型。没有减少约束的规则A&B << C。如果我们减少到

    A<<C 
  or
    A<<B

当前的任何推理引擎都必须进行大修，以允许这种分歧。但是真正的严重问题是，这允许有多种解决方案，但是没有理由偏爱一个。

但是，推断对于类型安全性不是必不可少的。在这种情况下，我们可以简单地拒绝推断，并要求程序员显式填充类型参数。因此，推理的难度并不是反对干涉类型的有力依据。

根据Java语言规范：

4.9交集类型交集类型采用T1＆...＆Tn，n> 0的形式，其中Ti，1in是类型表达式。交叉点类型出现在捕获转换（第5.1.10节）和类型推断（第15.12.2.7节）的过程中。不能将交集类型直接编写为程序的一部分；没有语法支持此功能。相交类型的值是那些对象，即所有类型Ti的值，为1in。

那为什么不支持呢？我的猜测是，您应该怎么做？-假设有可能：

List<? extends A & B> list = ...

那应该怎么办

list.get(0);

返回？没有语法可捕获的返回值A & B。也不可能在此列表中添加一些内容，因此基本上是没有用的。

没问题...只需在方法签名中声明所需的类型。

这样编译：

public static <T extends A & B> void main(String[] args) throws Exception
{
    AandBList<AandB> foo = new AandBList<AandB>(); // This works fine!
    foo.getList().add(new AandB());
    List<? extends A> bar = new LinkedList<AandB>(); // This is fine too
    List<T> foobar = new LinkedList<T>(); // This compiles!
}

好问题。我花了一段时间才弄清楚。

让我们简化一下情况：您试图做的事情就好像声明了一个扩展2个接口的类，然后声明一个具有这2个接口的类型的变量一样，如下所示：

  class MyClass implements Int1, Int2 { }

  Int1 & Int2 variable = new MyClass()

当然是非法的。这等效于您尝试使用泛型。您正在尝试做的是：

  List<? extends A & B> foobar;

但是，要使用foobar，您将需要以这种方式使用两个接口的变量：

  A & B element = foobar.get(0);

在Java中这是不合法的。这意味着，您将列表元素同时声明为两种类型的蜜蜂，即使我们的大脑可以处理它，Java语言也不能。

这样做的价值：如果有人因为真正想在实践中使用它而想知道它，我已经通过定义一个接口来解决这个问题，该接口包含了我正在使用的所有接口和类中所有方法的并集。即我正在尝试执行以下操作：

class A {}

interface B {}

List<? extends A & B> list;

这是非法的-所以我这样做了：

class A {
  <A methods>
}

interface B {
  <B methods>
}

interface C {
  <A methods>
  <B methods>
}

List<C> list;

这仍然不能像键入内容那样有用List<? extends A implements B>，例如，如果有人向A或B添加或删除方法，列表的类型将不会自动更新，而需要手动更改为C。但是它适用于我的需求