Java 泛型：非法的前向引用

Question

给定一个通用接口

interface Foo<A, B> { }

我想写一个实现，要求 A 是 B 的子类。所以我想做

class Bar<A, B super A> implements Foo<A, B> { }
// --> Syntax error

或

class Bar<A extends B, B> implements Foo<A, B> { }
// --> illegal forward reference

但似乎唯一可行的解​​决方案是：

class Bar<B, A extends B> implements Foo<A, B> { }

这有点难看，因为它颠倒了泛型参数的顺序。
这个问题有什么解决方案或变通方法吗？

Answer 1

由于这在 Java 中是不可能的，因此请尝试以不同的方式考虑 Bar<B, A extends B>。

当您为Bar 声明一个变量时，您首先指定了父类，然后是子类。这就是Bar 的工作原理。不要把它看作是倒退——把它看作是前进。父母自然应该在孩子之前指定。您添加的这个附加关系是驱动参数顺序的原因，而不是底层接口。

Answer 2

看到这个问题后，我花了一点时间尝试一些我认为可能有效的不同技术。例如，构建一个通用接口ISuper<B,A extends B>，然后拥有Bar<A,B> implements ISuper<B,A>（以及类似的技术与子类和扩展而不是实现）但这只会导致类型错误Bar.java:1: type parameter A is not within its bound。同样，我尝试创建一个方法private <A extends B> Bar<A,B> foo() { return this; }; 并从构造函数中调用它，但这只会导致有趣的类型错误消息Bar.java:2: incompatible types found : Bar<A,B> required: Bar<A,B>

所以，很遗憾，我认为答案是否定的。显然，这不是您希望的答案，但正确的答案似乎是这是不可能的。

Answer 3

已经指出，既没有解决方案，也没有很好的解决方法。这是我最终所做的。它仅适用于我的特殊情况，但如果您遇到类似问题，您可以将其作为灵感。 （这也解释了我遇到这个问题的原因）

首先有这个类（只显示相关界面）：

class Pipe<Input, Output> {

    boolean hasNext();

    Input getNext();

    void setNext(Output o);

}

Foo接口其实是

interface Processor<Input, Output> {

    process(Pipe<Input, Output> p);

}

Bar 的类应该像这样工作

class JustCopyIt<Input, Output> implements Processor<Input, Output> {

    process(Pipe<Input, Output> p) {
       while (p.hasNext()) p.setNext(p.getNext());
    }

}

最简单的方法是像这样转换值：p.setNext((Output) p.getNext())。 但这很糟糕，因为它允许创建JustCopyIt<Integer, String> 的实例。调用这个对象会在某些时候神秘地失败，但不会在实际错误发生的时候失败。

在这里执行class JustCopyIt<Type> implements Processor<Type, Type> 也行不通，因为那样我就无法处理Pipe<String, Object>。

所以我最后做的就是把界面改成这样：

interface Processor<Input, Output> {

    process(Pipe<? extends Input, ? super Output> p);

}

这样，JustCopyIt<List> 能够处理Pipe<ArrayList, Collection>。

虽然这在技术上似乎是唯一有效的解决方案，但它仍然很糟糕，因为它 1) 仅适用于这种特殊情况，2) 需要我更改接口（这并不总是可能的）和 3) 编写了代码其他处理器丑陋。

编辑：
再次阅读 Keiths 的回答启发了我另一种解决方案：

public abstract class Bar<A, B> implements Foo<A, B> {

    public static <B, A extends B> Bar<A, B> newInstance() {
        return new BarImpl<B, A>();
    }

    private static class BarImpl<B, A extends B> extends Bar<A, B> {
        // code goes here
    }

}

// clean code without visible reversed parameters
Bar<Integer, Object> bar1 = Bar.newInstance();
Bar<Object, Integer> bar2 = Bar.newInstance(); // <- compile error