类型转换 List<ChildClass> 到 List<BaseClass>

Question

我有一个这样的类结构：

public class BaseClass {

}

public class ChildClass extends BaseClass {

}

假设我有一个返回 List<BaseClass> 的方法 getList ：

public List<BaseClass> getList() {
     List<BaseClass> b = new ArrayList<>();
     return b;
}

List<BaseClass> b = getList();

我想让上述方法 getList() 通用，以便它可以根据某些条件返回 List<BaseClass> 或 List<ChildClass> 类型的对象，并将返回的值分配给 @987654326 类型的对象仅限@。这样做的原因是我正在处理一些遗留代码，其中对象的类型为 List<BaseClass>，我想避免将它们重构为 List<? extends BaseClass> 之类的东西，因为这会阻止这些列表对象上的 add() 等现有操作。

我了解List<BaseClass> 和List<ChildClass> 不是协变的。

但是，使用以下技术，我可以将 List<ChildClass> 转换为 List<BaseClass>，但我很困惑它是如何在幕后发生的，以及这样做是否正确。

使用显式转换：

List<BaseClass> b = new ArrayList<>();
List<ChildClass> c = new ArrayList<>();
b = c; // gives compilation error
b = (List<BaseClass>) c; // gives compilation error
b = (List<BaseClass>)(List<?>) c; // this works

使用泛型：

public List<ChildClass> getChildClassList() {
   // code to fetch/generate list and return
}

public List<BaseClass> getBaseClassList() {
   // code to fetch/generate list and return
}

public static <T extends BaseClass> List<T> getList() {
    if(something) {
        List<ChildClass> c = getChildClassList();
        return (List<T>) c; // this cast is required here.
    } else {
        List<BaseClass> b = getBaseClassList();
        return (List<T>) b;
    }
}

List<BaseClass> = getList(); // This works perfectly fine but,
                             // I dont understand how casting is happening here.
                             // Also with cast to List<T> inside getList how is the final return type determined?

使用通配符：

public List<ChildClass> getChildClassList() {
   // code to fetch/generate list and return
}

public List<BaseClass> getBaseClassList() {
   // code to fetch/generate list and return
}

public List<? extends BaseClass> getList() {
    if(something) {
        List<Child> c = getChildClassList();
        return c;
    } else {
        List<Base> b = getBaseClassList();
        return b;
    }
}

List<BaseClass> = getList(); // Gives compilation error saying incompatible types

// Casting this, however, works fine
List<BaseClass> = (List<BaseClass>) getList();

这些对我来说有点像 hack，可能是因为 Java 不支持直接转换。恐怕这里有一个我可能会遗漏的问题。

虽然这些对我的用例来说很好用，但我应该担心这种方法有什么含义吗？

写这样的代码安全吗？

这是一种糟糕的代码编写方式吗？如果是，那么应该如何处理？

Answer 1

我应该担心这种方法有什么影响吗？

对于一般情况，是的：您可以调用List<ChildClass> list = getList();，并最终得到一个列表，其中包含不是ChildClass 实例的内容。

从根本上说，您不能做任何会导致从方法中安全返回不同类型的任何事情。你能做的最好的就是通配符的情况：

List<? extends BaseClass> list = getList();

因为该列表中的所有内容要么是 BaseClass（有点风格），要么是 null。

然后您可以通过复制将其安全地转换为List<BaseClass>：

List<BaseClass> list2 = new ArrayList<>(list);

请注意，如果您使用像 Guava 的 ImmutableList 这样的东西，这个“副本”可能是免费的：

ImmutableList<BaseClass> list2 = ImmutableList.copyOf(list);

尽管有名字，copyOf 返回参数 cast，如果那是 ImmutableList 的一个实例，因为这是一个安全的协变转换。

---

在将list 转换为ChildClass 方面：在编译时您无能为力。你必须把它变成运行时检查：

// Throw an exception or something if this is false.
boolean allAreChildClass = list.stream().allMatch(e -> e == null || e instanceof ChildClass);

然后复制列表，执行强制转换。

List<ChildClass> list3 =
    list.stream().map(ChildClass.class::cast).collect(Collectors.toList());

或者，如果您可以确定 list 不会在其他任何地方使用，您可以简单地转换：

List<ChildClass> list3 = (List<ChildClass>) (List<?>) list;

但您必须真的确保list 不会在其他地方使用，或者不会被转换代码以外的任何东西修改。