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

您可以指定类型交叉点：

<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
        }
    }
}

是的，很难看。这就是为什么像Ceylon这样的新型JVM语言具有第一类交集类型的原因。也就是说，在锡兰，人们可以简单地写道：

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.然后，您可以使所有需要使用的类扩展新的抽象类。

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

4 个答案: