Question

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

我有一个需要Context的Processor类。有不同类型的Context;大多数处理器只需要任何抽象的Context，但其他处理器需要特定的子类。像这样：

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类型应该能够注册其他的Processor。这是我能找到的最接近工作解决方案的地方，但它不能完全发挥作用：

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，但我希望type-variable引用每个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);
    }
}

Answer 1

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

class Context<C extends Context<C>>

注意泛型参数的递归使用 - 这有点难以包围，但它forces the subclass to refer to exactly itself。（说实话，我并不完全得到这个，但只要你记得它有效，它就可以工作。作为参考，Enum类的定义方式完全相同。）Angelika Langer的Generics FAQ中还有一节covers this。

这样编译器可以获得有关哪些类型是允许的更多信息，并且应该允许您的案例在没有多余的转换的情况下进行编译。

更新：考虑到这一点，我上面的评论是在正确的轨道上，但并不完全是钱。使用自递归泛型边界，如上所述，您永远不能真正使用您定义它们的实际类。我以前从来没有完全注意到这一点，因为通过运气或判断，我显然总是在类层次结构的正确位置使用它。

但我花时间尝试让代码编译 - 并实现了一些东西。具有这些边界的类永远不会被称为自身，它只能在特定子类的上下文中引用。例如，考虑BasicProcessor的定义 - Context在AbstractProcessor的通用边界中显得不合理。为了防止出现原始类型，有必要将类定义为：

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

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

class SpecificContext extends Context<SpecificContext>

我认为这基本上是这里的问题 - 编译器不能保证C和Context<C>是相同的类型，因为它没有必要的特殊外壳逻辑来解决这两个问题实际上是一个等价的类型（只有当wilcard链接是无限的时才能实际出现，因为在任何非无限的意义上，后者在扩展时总是比第一级更深一层。）

所以这不是一个很好的结论，但我认为在这种情况下你的演员阵容是必需的，因为编译器无法为自己派生等价。或者，如果使用类似位置的Context的具体子类，则编译器能够解决这个问题。这不是问题。

如果您确实找到了一种方法来在不进行强制转换或不必插入虚拟子类的情况下使其工作，那么请回报 - 但我看不到这样做的方法，这将与可用的语法和语义一起使用到Java的泛型。

需要java泛型声明的派生类

1 个答案: