Question

Got a little puzzle for a true Java Generics specialist… 😉

Let’s say I have the following two interfaces:

interface Processor {
    void process(Foo foo);
}

interface Foo {
    Processor getProcessor();
}

and, for example, the following two implementing classes:

static class SomeProcessor implements Processor {
    static final SomeProcessor INSTANCE = new SomeProcessor();

    @Override
    public void process(Foo foo) {
        if (foo instanceof SomeFoo) { // <-- GET RID OF THIS ?
            // process ((SomeFoo) foo)
        }
    }
}

class SomeFoo implements Foo {
    @Override
    public Processor getProcessor() {
        return SomeProcessor.INSTANCE;
    }
}

Is there some way to make the two interfaces generic in such a way that I don’t need the marked instanceof check in the process() function and still have the following construct work elsewhere in my code?

foo.getProcessor().process(foo);

(where, of course, I don’t know what subclass of Foo I’m dealing with)

In other words: I’m looking for a way to define a function in an object such that it can only return another object that processes the type of object that contained the function. Note: I’m not just talking about processing some least common denominator super-class of the object containing the function (above: Foo), but that object’s actual class (above: SomeFoo).

(This is nowhere near as trivial as it may sound unless I’m really being stupid right now…)

Answer 1

This is uglier than I thought. My take:

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

Now, the following will compile:

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

but

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

doesn’t, because the compiler can not know that actual type of the passed foo is a subtype of its type parameter, as somebody could write:

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

We can work around this by requiring the subtypes of foo to implement a conversion to their type parameter:

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();
    }
}

Now, we can write:

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

and invoke this with

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

To make it easy to use, I recommend moving the helper method into class Foo:

abstract class Foo<F extends Foo<F>> {
    abstract Processor<F> getProcessor();

    abstract F getThis();

    void processWith(Processor<F> p) {
        p.process(getThis());
    }
}

Update: I think newaccts updated answer shows a more elegant solution, as it does not need the recursive type bounds.