Why is this type not a valid substitute for the type parameter?

Question

I\'m experimenting with using generics to support a configurable structure of delegating objects (decorators, wrappers). I want to build a chain of delegators that implement

Answer 1

What should work instead is, if FooDelegator implements Delegator<FooDelegator> or Foo implements Delegator<Foo>. Because this is what you are requiring for the DelegatorChain: T implements Delegator<T>.

Third alternative, which should work as well:

DelegatorChain<T extends Delegator<F>, F> chain; ...

Answer 2

It looks like this is what you are trying to do.

static interface Delegator<T> {
    }

    static class DelegatorChain<T extends Delegator<C>, C> {
    }

    static interface Foo {
    }

    static class FooDelegator implements Delegator<Foo>, Foo {
    }

    public static void main(String[] args) {
        DelegatorChain<FooDelegator, Foo> chain = new DelegatorChain<FooDelegator, Foo>();
    }

Your initial example does not compile because the types are not correct. The Generic type in DelegatorChain is a "FooDelegator" but the generic type required in the Delegator is "Foo". You'll need the extra generic type parameter that i provided in my answer to make it work as you intended.

You could also leave the constraint off entirely on DelegatorChain i.e. DelegatorChain.

Answer 3

Under your definition, a Delegator is a Delegator of itself (like Comparable is for example), however it seems the intention is that Delegator is a Delegator of a super class. Luckily, generics has a way of expressing this:

static class DelegatorChain<T extends Delegator<? super T>> {}

This says that the "Delagator type must be a super class of T". With this change, the rest of your original code compiles:

static interface Delegator<T> {}
static class DelegatorChain<T extends Delegator<? super T>> {}
static interface Foo {}
static class FooDelegator implements Delegator<Foo>, Foo {}

public static void main(String[] args) {
    DelegatorChain<FooDelegator> chain = new DelegatorChain<FooDelegator>();
}

Also, anytime you use a generic super bound, your code looks really cool :)

Note: This following was originally the "first option" in the question.
There is another way to get your code to compile, but it is inferior because it loses the connect between the Delegator type and what it's delegating from:

// Not recommended, but will allow compile:
static class FooDelegator implements Delegator<FooDelegator>, Foo {} 
// However, this also compiles :(
static class FooDelegator implements Delegator<FooDelegator>, Bar {}