Pattern Strategy and generics

Question

Hi there !
I'm trying to implements a strategy pattern by using generics.
That is my attempt for the abstract part :
public interface Strategy<C extends Compound> {
        public abstract void apply(final C c);
    public abstract class Compound {
        Strategy<? super Compound> strategy;
        public void setStrategy(Strategy<? super Compound> strategy) {
            this.strategy = strategy;
        public final void move() {
            this.strategy.apply(this);
    }But when I want to use it :
    public class AStrategy implements Strategy<ACompound> {
        public void apply(ACompound compound) {
            return;
    public class ACompound extends Compound {
        public ACompound(AStrategy strategy) {
            // setStrategy(Strategy<? super Compound>) in Compound cannot be applied to (AStrategy)
            this.setStrategy(strategy); // BOOM !
    }So I think that I don't use correctly the wildcards and bounds ... What's wrong ?
Thanks

Answer 1

Sorry not to really offer an actual explanation...I'm not sure I could get one right, so I'll leave that to an actual Expert!
But here's another way of writing that example. It's maybe more heavyweight than what you want (and maybe also you'll get more replies telling you all the reason why it's a Bad Approach!), but it will compile for you.
interface Strategy<S extends Strategy<S,C>, C extends Compound<S,C>>   {
        public abstract void apply(final Compound<S,C> c);
abstract class Compound<S extends Strategy<S,C>, C extends Compound<S,C>> {
        Strategy<S,C> strategy;
        public void setStrategy(Strategy<S,C> strategy) {
            this.strategy = strategy;
        public final void move() {
            this.strategy.apply(this);
    }The basic idea is that Strategy and Compound define a way for two classes to relate to each other. If you declare classes XXX and YYY (respectively) to be a Strategy/Compound relationship, then you know that all of the business relating to Compound in XXX should actually be about YYY. It's just the same thing as knowing you get a String out of an Iterator<String>, except that it goes back and forth between two different classes. So your two concrete classes become:
class AStrategy implements Strategy<AStrategy, ACompound> {
        public void apply(Compound<AStrategy, ACompound> compound) {
            return;
class ACompound extends Compound<AStrategy, ACompound> {
        public ACompound(AStrategy strategy) {
            this.setStrategy(strategy); // BOOM !
    }Of course, overusing this leads to amazingly long type variable lists.