为什么 Java 中的泛型类型参数不能有下限？

Question

我认为您不能将 Java 泛型类型参数绑定到下限（即使用 super 关键字）。我正在阅读 Angelika Langer Generics 常见问题解答关于该主题的内容 。他们说这基本上可以归结为无用的下限（“没有任何意义”）。

我不相信。我可以想象它们的用途是帮助您更灵活地处理生成类型化结果的库方法的调用者。想象一个方法，它创建了用户指定大小的数组列表并用空字符串填充它。一个简单的声明是

public static ArrayList<String> createArrayListFullOfEmptyStrings(int i);

但这对您的客户造成了不必要的限制。为什么他们不能像这样调用你的方法：

//should compile
List<Object> l1 = createArrayListFullOfEmptyStrings(5); 
List<CharSequence> l2 = createArrayListFullOfEmptyStrings(5);
List<String> l3 = createArrayListFullOfEmptyStrings(5);

//shouldn't compile
List<Integer> l4 = createArrayListFullOfEmptyStrings(5);

此时我很想尝试以下定义：

public static <T super String> List<T> createArrayListFullOfEmptyStrings(int size) {
  List<T> list = new ArrayList<T>(size);
  for(int i = 0; i < size; i++) {
     list.add("");
  }
  return list;
}

但它不会编译； super 关键字在此上下文中是非法的。

我上面的例子是一个坏例子吗（忽略我下面所说的）？为什么下限在这里没有用？如果它有用，那么 Java 中不允许它的真正原因是什么？

PS

我知道更好的组织可能是这样的：

public static void populateListWithEmptyStrings(List<? super String> list, int size);

List<CharSequence> list = new ArrayList<CharSequence>();
populateListWithEmptyStrings(list, 5);

我们可以为此目的吗？问题假装由于需求，我们需要在一个方法调用中执行这两个操作？

编辑

@Tom G（有道理）询问 List 相对于 List 有什么好处。其一，没有人说返回的列表是不可变的，所以这是一个优点：

List<CharSequence> l2 = createArrayListFullOfEmptyStrings(5);
l2.add(new StringBuilder("foo").append("bar"));

Answer 1

基本上，它不够有用。

我认为您的示例指出了下限的唯一优点，常见问题解答将其称为受限实例化：

底线是：“超级”束缚会买给你的全部是限制只有 Number 的超类型可以用作类型参数。 ....

但正如其他帖子所指出的，即使这个功能的用处也可能是有限的。

由于多态性和专业化的本质，上限比常见问题解答中描述的下限有用得多（访问非静态成员和类型擦除）。我怀疑下限带来的复杂性不值得其有限的价值。

---

OP：我想补充一点，我认为你确实表明它很有用，但还不够有用。提出无可辩驳的杀手级用例，我就会支持 JSR。 :-)

Answer 2

例如，规范确实讨论了类型参数的下限

4.10.2

类型变量是其下界的直接超类型。

2010年5月1日

一个新的类型变量......其下界

看起来，如果类型变量是通配符捕获的合成变量，则该类型变量只有一个（非空）下界。如果语言允许所有类型参数的下限怎么办？也许它不会造成很多麻烦，并且排除它只是为了使泛型更简单（嗯...）更新据说对下界类型参数的理论研究尚未彻底进行。

更新：一篇声称下界可以的论文：Daniel Smith 的“Java 类型推断已损坏：我们可以修复它吗”

撤回：以下参数是错误的。 OP的例子是合法的。

你的具体例子不是很有说服力。首先它不是类型安全的。返回的列表确实是一个 List，将其视为其他类型是不安全的。假设您的代码可以编译：

    List<CharSequence> l2 = createArrayListFullOfEmptyStrings(5);

那么我们可以向其中添加非 String，这是错误的。

    CharSequence chars = new StringBuilder();
    l2.add(chars); 

List 不是这样，而是有点像 CharSequence 列表。您的需求可以通过使用通配符来解决：

public static  List<String> createArrayListFullOfEmptyStrings(int size)  

// a list of some specific subtype of CharSequence 
List<? extends CharSequence> l2 = createArrayListFullOfEmptyStrings(5);

// legal. can retrieve elements as CharSequence
CharSequence chars = l2.get(0);

// illegal, won't compile. cannot insert elements as CharSequence
l2.add(new StringBuilder());

Answer 3

这不仅仅是一个答案，这是另一个（可能是杀手？）用例。
我有一个 ModelDecorator 助手。我希望它具有以下公共 API

class ModelDecorator<T>{
    public static <T> ModelDecorator<T> create(Class<T> clazz);
    public <SUPER> T from(SUPER fromInstance);
}

因此，给定类 A、B 扩展 A，它可以像这样使用：

A a = new A();
B b = ModelDecorator.create(B.class).from(a);

但我希望在 T 和 SUPER 上有界限，所以我确保只有子类可以使用 API 实例化。此时，我可以这样做：

C c = new C();
B b = ModelDecorator.create(B.class).from(c);

其中B不继承自C。

显然，如果我可以这样做：

    public <SUPER super T> T from(SUPER fromInstance);

那将解决我的问题。

Answer 4

此时输入列表会给您带来什么好处？当您迭代返回的集合时，您仍然应该能够执行以下操作：

for(String s : returnedList) {
CharSequence cs = s;
//do something with your CharSequence
}

Answer 5

编辑：我带来了好消息。有一种方法可以得到你想要的大部分东西。

public static <R extends List<? super String>> R createListFullOfEmptyString(IntFunction<R> creator, int size)
{
  R list = creator.apply(size);
  for (int i = 0; i < size; i++)
  {
    list.add("");
  }
  return list;
}

// compiles
List<Object> l1 = createListFullOfEmptyString(ArrayList::new, 5);
List<CharSequence> l2 = createListFullOfEmptyString(ArrayList::new, 5);
List<String> l3 = createListFullOfEmptyString(ArrayList::new, 5);
// doesn't compile
List<Integer> l4 = createListFullOfEmptyString(ArrayList::new, 5);

缺点是客户端确实需要提供 R 的实例来进行变异，或者提供某种构造 R 的方法。没有其他方法可以安全地构造它。

我将保留下面的原始答案以供参考。

---

总之：

没有充分的理由，只是还没有完成。

并且在此之前，不可能为执行以下所有操作的方法编写具有正确方差的精确类型：

A) 接受或创建参数化数据结构

B) 将计算的（未传入的）值写入该数据结构

C) 返回该数据结构

写入/接受值正是应用逆变的情况，这意味着类型参数数据结构上的下限必须由写入数据结构的值的类型决定。当前在 Java 中表达这一点的唯一方法是在数据结构上使用下限通配符，例如 List。

---

如果我们正在设计一个像 OP 这样的 API，它可能自然地（但不合法）表达为：

// T is the type of the value(s) being computed and written to the data structure

// Method creates the data structure
<S super T> Container<S> create()

// Method writes to the data structure
<S super T> Container<S> write(Container<S> container)

那么我们可用的选项是：

A) 使用下限通配符，并强制调用者强制转换输出：

// This one is actually useless - there is no type the caller can cast to that is both read- and write-safe.
Container<? super T> create()

// Caller must cast result to the same type they passed in.
Container<? super T> write(Container<? super T> container)

B)过度限制数据结构上的类型参数以匹配正在写入的值的类型，并强制调用者强制转换输入和输出：

// Caller must accept as-is; cannot write values of type S (S super T) into the result.
Container<T> create()

// Caller must cast Container<S> (S super T) to Container<T> before calling, then cast the result back to Container<S>.
Container<T> write(Container<T> container)

C) 使用新的类型参数并在内部执行我们自己的不安全转换:

// Caller must ensure S is a supertype of T - we cast T to S internally!
<S> Container<S> create()

// Caller must ensure S is a supertype of T - we cast T to S internally!
<S> Container<S> write(Container<S> container)

选择你的毒药。

Answer 6

这会让你几乎到达目标。

static public void main(String...args){
    List<Object> l1 = createArrayListFullOf("", 5);
    List<CharSequence> l2 = createArrayListFullOf("", 5);
    List<String> l3 = createArrayListFullOf("", 5);

    // vvv compile time error vvv
    List<Integer> l4 = createArrayListFullOf("", 5);
}


public static <T, E extends T> List<T> createArrayListFullOf(E value, int size) {
    List<T> list = new ArrayList<T>(size);
    for (int i = 0; i < size; i++) {
        list.add(value);
    }
    return list;
}

我认为这可能更接近您正在寻找的东西。基本上，通过使 E 扩展 T，T 成为 E 的超类。问题是您需要一些 T 类型的引用 - 即需要绑定的 E。在这种情况下，添加了一个绑定到 E 的值填充参数。

Answer 7

嗯，好吧 - 让我们一起解决这个问题。您定义一个方法：

public static列表createArrayListFullOfEmptyStrings(int size) {

这是什么意思？这意味着如果我调用你的方法，那么我会得到一个 String 的某个超类的列表。也许它返回一个字符串列表。也许它返回一个对象列表。我不知道。

凉爽的。

列表<对象> l1 = createArrayListFullOfEmptyStrings(5);

根据您的说法，应该可以编译。但那是不对的！我可以将一个整数放入对象列表中 - l1.add(3) 。但如果你返回一个字符串列表，那么这样做应该是非法的。

列表<字符串> l3 = createArrayListFullOfEmptyStrings(5);

根据您的说法，应该可以编译。但那是不对的！ l3.get(1) 应该始终返回一个 String ...但该方法可能返回一个 Object 列表，这意味着 l3.get(1) 可能是一个 Integer。

唯一有效的是

List l5 = createArrayListFullOfEmptyStrings(5);

我所知道的是我可以安全地调用 l4.put("foo")，并且我可以安全地获取 Object o = l4.get （2）。