如何用编译时泛型验证替换运行时instanceof check

这比我想的还要丑。我的看法：

interface Processor<F extends Foo<F>> {    void process(F foo);}interface Foo<F extends Foo<F>> {    Processor<F> getProcessor();}interface SomeFoo extends Foo<SomeFoo> {    @Override    SomeProcessor getProcessor();}interface SomeProcessor extends Processor<SomeFoo> {    @Override    void process(SomeFoo foo);}

现在，将编译以下内容：

<F extends Foo<F>> void process(F foo) {    foo.getProcessor().process(foo);}

但

void process(Foo<?> foo) {    foo.getProcessor().process(foo);}

不会，因为编译器无法知道所传递的foo的实际类型是其类型参数的子类型，就像有人可以这样写：

    class Bar implements Foo<SomeFoo> { ... }

我们可以通过要求foo的子类型实现对其类型参数的转换来解决此问题：

abstract class Foo<F extends Foo<F>> {    abstract Processor<F> getProcessor();    abstract F getThis();}class SomeFoo extends Foo<SomeFoo> {    @Override    SomeFoo getThis() {        return this;    }    @Override    Processor<SomeFoo> getProcessor() {        return new SomeProcessor();    }}

现在，我们可以写：

<F extends Foo<F>> void process(Foo<F> foo) {    foo.getProcessor().process(foo.getThis());}

并用

Foo<?> foo = ...;process(foo);

为了易于使用，我建议将helper方法移到Foo类中：

abstract class Foo<F extends Foo<F>> {    abstract Processor<F> getProcessor();    abstract F getThis();    void processWith(Processor<F> p) {        p.process(getThis());    }}

更新：我认为newaccts更新的答案显示了一个更优雅的解决方案，因为它不需要递归类型界限。