我遇到了一个棘手的问题，似乎无法用 Java 泛型解决。这有点复杂，但我想不出一个更简单的场景来说明问题......这里是:

我有一个需要上下文的处理器类。上下文有不同的类型；大多数处理器只需要任何抽象上下文，但其他处理器需要特定的子类。像这样:

abstract class AbstractProcessor<C extends Context> {
    public abstract void process(C context);
}

class BasicProcessor extends AbstractProcessor<Context> {
    @Override
    public void process(Context context) {
        // ... //
    }
}

class SpecificProcessor extends AbstractProcessor<SpecificContext> {
    @Override
    public void process(SpecificContext context) {
        // ... //
    }
}

好的，很酷:处理器可以声明他们需要的上下文类型，并且他们可以假设正确的类型将被传递到 process() 而无需转换。

现在，我有一个 Dispatcher 类，它拥有字符串到处理器的映射:

class Dispatcher<C extends Context> {
    Map<String, AbstractProcessor<? super C>> processorMap = new HashMap<String, AbstractProcessor<? super C>>();

    public void registerProcessor(String name, AbstractProcessor<? super C> processor) {
        processorMap.put(name, processor);
    }

    public void dispatch(String name, C context) {
        processorMap.get(name).process(context);
    }
}

好的，到目前为止一切顺利!我可以为特定类型的 Context 创建一个 Dispatcher，然后注册一批可能需要该 Context 类型的任何抽象的处理器。

现在，问题来了:我希望抽象 Context 类型拥有 Dispatcher，而派生的 Context 类型应该能够注册额外的处理器。这是我能找到的最接近可行的解决方案，但它并不完全有效:

class Context<C extends Context> {
    private final Dispatcher<C> dispatcher = new Dispatcher<C>();

    public Context() {
        // every context supports the BasicProcessor
        registerProcessor("basic", new BasicProcessor());
    }

    protected void registerProcessor(String name, AbstractProcessor<? super C> processor) {
        dispatcher.registerProcessor(name, processor);
    }

    public void runProcessor(String name) {
        dispatcher.dispatch(name, this); // ERROR: can't cast Context<C> to C
    }
}

// this is totally weird, but it was the only way I could find to provide the
// SpecificContext type to the base class for use in the generic type
class SpecificContext extends Context<SpecificContext> {
    public SpecificContext() {
        // the SpecificContext supports the SpecificProcessor
        registerProcessor("specific", new SpecificProcessor());
    }
}

问题是我需要在 Context 基类中声明一个通用 Dispatcher，但我希望类型变量引用每个 Context 子类型的特定 派生 类型。如果不在每个 Context 子类中复制一些代码(特别是 Dispatcher 和 registerProcessor 方法的构造)，我看不出有什么方法可以做到这一点。这是我认为我真正想要的:

Dispatcher<MyRealClass> dispatcher = new Dispatcher<MyRealClass>();

有没有办法用声明类的 SUBCLASS 类型来声明对象的泛型类型？

是的，我可以通过一些低风险的转换来解决这个问题，所以这主要是一个学术问题......但我很想找到一个从上到下都有效的解决方案!你能帮我吗？您将如何处理这种架构？

更新:

这是完整的源代码，已更新以纳入 Andrzej Doyle 使用 <C extends Context<C>> 的建议;它仍然不起作用，因为Context<C> != C :

class Context<C extends Context<C>> {
    private final Dispatcher<C> dispatcher = new Dispatcher<C>();

    public Context() {
        // every context supports the BasicProcessor
        registerProcessor("basic", new BasicProcessor());
    }

    protected void registerProcessor(String name, AbstractProcessor<? super C> processor) {
        dispatcher.registerProcessor(name, processor);
    }

    public void runProcessor(String name) {
        dispatcher.dispatch(name, this); // ERROR: can't cast Context<C> to C
    }
}

// this is totally weird, but it was the only way I could find to provide the
// SpecificContext type to the base class for use in the generic type
class SpecificContext extends Context<SpecificContext> {
    public SpecificContext() {
        // the SpecificContext supports the SpecificProcessor
        registerProcessor("specific", new SpecificProcessor());
    }
}

abstract class AbstractProcessor<C extends Context<C>> {
    public abstract void process(C context);
}

class BasicProcessor extends AbstractProcessor {
    @Override
    public void process(Context context) {
        // ... //
    }
}

class SpecificProcessor extends AbstractProcessor<SpecificContext> {
    @Override
    public void process(SpecificContext context) {
        // ... //
    }
}

class Dispatcher<C extends Context<C>> {
    Map<String, AbstractProcessor<? super C>> processorMap = new HashMap<String, AbstractProcessor<? super C>>();

    public void registerProcessor(String name, AbstractProcessor<? super C> processor) {
        processorMap.put(name, processor);
    }

    public void dispatch(String name, C context) {
        processorMap.get(name).process(context);
    }
}

最佳答案

听起来您的问题是您需要泛型来引用子类的特定确切类型，而不是从父类继承泛型定义。尝试将您的上下文类定义为

class Context<C extends Context<C>>

请注意通用参数的递归使用 - 这有点难以理解，但它 forces the subclass to refer to exactly itself . (老实说，我不太明白这个，但只要你记得它有效，它就有效。作为引用，Enum 类的定义方式完全相同。) Angelika Langer 的泛型常见问题解答中还有一个部分 covers this .

通过这种方式，编译器可以获得更多关于允许使用哪些类型的信息，并且应该允许您的案例在没有多余强制转换的情况下进行编译。

更新:经过仔细考虑，我的上述评论是正确的，但并不完全是为了赚钱。如上所述，使用自递归泛型边界，您永远无法真正使用定义它们的实际类。事实上，我以前从未完全注意到这一点，因为运气或判断，我显然总是在类层次结构的正确位置使用它。

但我花时间尝试让您的代码编译 - 并意识到了一些事情。具有这些边界的类永远不能被称为它自己，它只能在特定子类的上下文中被引用。考虑 BasicProcessor 的定义例如 - Context在 AbstractProcessor 的通用边界中出现非通用化.为了防止出现原始类型，有必要将类定义为:

class BasicProcessor extends AbstractProcessor<Context<Context<Context<...

子类避免了这种情况，因为它们在定义中包含了递归性:

class SpecificContext extends Context<SpecificContext>

我认为这就是这里的根本问题 - 编译器无法保证 C和 Context<C>是相同的类型，因为它没有所需的特殊外壳逻辑来计算出两者实际上是等效类型(实际上只有当通配符链接是无限的时候才会出现这种情况，因为在任何非无限意义上后者在展开时总是比第一层深一层)。

所以这不是一个很好的结论，但我认为在这种情况下，您需要强制转换，因为编译器无法为自己推导出等价关系。或者，如果您正在使用 Context 的具体子类在类似的位置，编译器能够解决这个问题，这不是问题。

如果您碰巧找到了一种无需强制转换或无需插入虚拟子类即可实现此功能的方法，请报告回来 - 但我看不到一种方法可以做到这一点，这将适用于可用的语法和语义到 Java 的泛型。

关于java - java泛型声明需要派生类，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/2011782/