Java 泛型帮助：无法使用“Object”作为“？”的论点扩展对象”

Question

我有以下代码：

import java.util.*;

public class SellTransaction extends Transaction {
    private Map<String,? extends Object> origValueMap;
    public SellTransaction(Map<String,? extends Object> valueMap) {
        super(Transaction.Type.Sell);
        assignValues(valueMap);
        this.origValueMap=valueMap;
    }
    public SellTransaction[] splitTransaction(double splitAtQuantity) {
        Map<String,? extends Object> valueMapPart1=origValueMap;
        valueMapPart1.put(nameMappings[3],(Object)new Double(splitAtQuantity));
        Map<String,? extends Object> valueMapPart2=origValueMap;
        valueMapPart2.put(nameMappings[3],((Double)origValueMap.get(nameMappings[3]))-splitAtQuantity);
        return new SellTransaction[] {new SellTransaction(valueMapPart1),new SellTransaction(valueMapPart2)};
    }
}

当我调用 valueMapPart1.put 和 valueMapPart2.put 时，代码无法编译，并出现错误：

The method put(String, capture#5-of ? extends Object) in the type Map is not applicable for the arguments (String, Object)

我在 Internet 上阅读了有关泛型和通配符的信息并捕获，但我仍然不明白出了什么问题。我的理解是，Map 的值可以是任何扩展 Object 的类，我认为这可能是多余的，因为所有类都扩展 Object。我无法将泛型更改为类似 的内容？ super Object，因为 Map 是由某个库提供的。

那么为什么这不能编译呢？另外，如果我尝试将 valueMap 转换为 Map，编译器会向我发出“未经检查的转换”警告。

谢谢！

Answer 1

如果库指定extends，那么它们明确禁止put。您应该在修改之前进行防御性复制，因为它们可以完全合法地将其返回类型更改为在新版本中不可变。如果复制成本很高，那么您可以尝试创建 类型的地图类型，它首先查询其地图，然后查询您创建的具有本地修改的地图。

如果您确实知道它们的返回类型是不可变的并且您单独拥有它，那么 @SuppressWarnings("unchecked") 注释是解决警告的合法方法，但我会仔细检查这些广泛的假设和评论。

要理解 extends 与 super，请这样看。
由于该值可以是任何扩展 Object 的类型，因此以下内容是有效的。

Map<String, Number> strToNum = new HashMap<String, Number>();
strToNum.put("one", Integer.valueOf(1));  // OK

Map<String, String> strToStr = new HashMap<String, String>();
strToStr.put("one", "1");  // OK

Map<String, ? extends Object> strToUnk = randomBoolean() ? strToNum : strToStr;
strToUnk.put("null", null);  // OK.  null is an instance of every reference type.
strToUnk.put("two", Integer.valueOf(2));  // NOT OK.  strToUnk might be a string to string map
strToUnk.put("two", "2");  // NOT OK.  strToUnk might be a string to number map

因此，put 并不真正适用于 extends 边界类型。
但它与像 get 这样的读取操作完美配合：

Object value = strToUnk.get("one");  // We don't know whether value is Integer or String, but it is an object (or null).

如果您希望地图主要与“put”而不是“get”一起使用，那么您可以使用“super”而不是扩展，如下所示：

Map<String, Number> strToNum = new HashMap<String, Number>();
Map<String, Object> strToObj = new HashMap<String, Object>();

Map<String, ? super Number> strToNumBase;
if (randomBoolean()) {
  strToNumBase = strToNum;
} else {
  strToNumBase = strToObj;
}

// OK.  We know that any subclass of Number can be used as values.
strToNumBase.put("two", Double.valueOf(2.0d));

// But now, gets don't work as well.
Number n = strToNumBase.get("one");  // NOT OK. 

Answer 2

据我所知，有界宽卡，即？ extends Number，不用于变量或字段。它通常用于方法的参数。

我们首先考虑没有泛型类型的情况。

public void method(List<Number> list) {
}

用法示例：

method(new List<Double>()); // <-- Java compiler complains about this
method(new List<Number>()); // <-- Java compiler is happy with this.

您只能将 Number 的 List 传递给此方法，而不能将 Double 的 List 传递给此方法，即使Double 是 Number 的子类。

此处可以使用 Widecard 泛型来告诉 java 编译器此方法可以接受 Number 的子类的任何列表。

public void method(List<? extends Number> list) {
}

用法示例：

method(new List<Double>()); // <-- Java compiler is happy with this.
method(new List<Number>()); // <-- Java compiler is happy with this.

但是，您将无法再修改列表对象，例如

public void method(List<? extends Number> list) {
    list.add(new Double()); // this is not allowed
}

上面的列表现在具有“Number的未知子类型”类型，可以是List、List、List等。将 Double 对象添加到未知类型列表中肯定是不安全的。为了说明这一点，对方法的调用是

method(new ArrayList<Integer>());

...
public void method(List<? extends Number> list) {
    // adding Double to Integer list does not make sense.
    list.add(new Double()); // compiler error
}

对于变量和字段，您通常不使用有界宽卡，您可以这样做

private Map<String, Object> origValueMap;

...

Map<String, Object> valueMapPart1 = origValueMap;
valueMapPart1.put(nameMappings[3], new Double(splitAtQuantity));

注意：无需将 new Double(splitAtQuantity) 转换为其超类型，例如 Number 或 Object。

Answer 3

这确实涉及到一个古老的面向对象问题。乍一看，“一袋苹果”似乎是“一袋水果”的子类，但事实并非如此。对于面向对象的代码，您始终可以使用子类代替超类（这称为 里氏替换原则）。一袋苹果就打破了这一点，因为它不接受橙子，而一袋水果会接受橙子。

就问题而言， Collection could 是 Collection