Java：是否可以说变量类型必须满足多重继承/接口要求

Question

在我正在使用的一些代码中，我有一个现有的第三方 API，它实现了从 A 扩展的东西（也许不是直接的，而是通过 X，也许还实现了一堆其他接口）。

现在对于我正在处理的代码，我有一个接口 IB，它为 A 提供的功能提供了额外的功能。因此，我的很多代码实际上都要求传递给它的对象扩展 A，并且还实现了 IB，但是对于我能想到的成员变量，没有办法声明它。但是选择 A 或 IB 会导致很多演员。

我猜如果 A 是/有一个接口 IA 会解决这个问题，但是我无法更改 A，或者我的 IB 实现不需要扩展 A（第三方代码使用 A，并注意通过它进行大量管理、持久性、网络、用户界面等）。

class Z {
    private List<?what here?> items;
    /**The implementer of IB should know how to find the Z instance and call this.*/
    private void subscribe(? item) {
        items.add(item);
    }
    public void doSomethingWithItems() {
        ...code thats requires facilities from A and IB...
    }

Answer 1

你可以指定一个类型intersection：

<T extends A & IB>

规则是，如果其中一个类型是类，则必须首先列出。

如果可以的话，我会输入课程：

class Z<T extends A & IB> {
    private List<T> items;

    private void subscribe(T item) {
        items.add(item);
    }
    public void doSomethingWithItems() {
        // the items are both A and IB
    }
}

如果您不能输入 Z，请使用类型化方法：

class Z {
    private List<A>items;

    private <T extends A & IB> void subscribe(T item) {
        items.add(item);
    }
    public void doSomethingWithItems() {
        // items are A, but if you want IB functionality you must cast.
        // the cast is safe if items are only added via subscribe()
    }
}

Answer 2

使用通用帮助类，其类型参数允许您使用类型交集：

class Z {

    private static final class Wrapper<T extends A & IB> {

        private final T item;

        Wrapper(final T item) {
            this.item = item;
        }

        void doWork() {
            // code thats requires facilities from A and IB
        }
    }

    private List<Wrapper<?>> wrappers;

    private <T extends A & IB> void subscribe(T item) {
        wrappers.add(new Wrapper<T>(item));
    }
    public void doSomethingWithItems() {
        for (final Wrapper<?> wrapper : wrappers) {
            wrapper.doWork();
        }
    }

我在这篇文章中给出了类似的答案：Java generics type mismatch in method signature

Answer 3

如果 IB 是 IA 的子类型，那将是最符合概念的，但如果你不能这样做......

很难在代码中表达这一点，因为 Java 不支持第一类交集类型。也就是说，Java 只支持类型参数边界内的交集类型，我们不能在字段声明中使用类型参数而不要求列表的所有元素都是相同的 IB 子类型。

因此，我能想到的最佳近似是仅在公共 API 中强制执行约束，并在内部使用强制转换：

class Z {
    private List<A> items;

    private <B extends A & IB> void subscribe(B item) {
        items.add(item);
    }

    public void doSomethingWithItems() {
        for (A a : items) {
            IB b = (IB) a; // safe because we checked it on subscription
            // use features of A and IB
        }
    }
}

是的，它很丑。这就是为什么新的 JVM 语言（例如 Ceylon）具有一流的交集类型的原因。也就是说，在锡兰，人们可以简单地写：

class Z() {

    List<A & IB> items;

    void subscribe(A & IB item) {
        items.add(item);
    }

    void doSomethingWithItems() {
        for (item in items) {
            // use features of A and IB
        }
    }
}

Answer 4

你可以创建一个新的抽象类，它既用抽象方法实现 IB，又扩展了 A。然后你可以让你需要使用的所有类扩展你的新抽象类。