MyClass T extends MyClass T problem

Question

Hi, I have the following two abstract classes in the same package:
public abstract class State <T> {
  private T owner;
  void setOwner(T owner) {
    this.owner = owner;
public abstract class MyClass <T extends MyClass<T>> {
  private State<T> state;
  public void setState(State<T> state) {
    this.state = state;
    this.state.setOwner(this);
}The idea is that if I create a new class, say MyClassSub, that extends MyClass, then it should supply itself as the type parameter for MyClass, eg:
public class MyClassSub extends MyClass<MyClassSub> {
}The point of this is that when such a class is created, it can only set subclasses of State<MyClassSub> as its "state" variable, and the "owner" variable in the state is automatically updated within the setState method. (Notice how the setOwner method is hidden from public, visible only inside the package).
The problem is that this doesn't compile. I get the error:
setOwner(T) in State<T> cannot be applied to (MyClass<T>)
   this.state.setOwner(this);
   ^Any ideas?

Answer 1

Thanks for your reply.
My understanding is that you are trying to assign a
supertype to a subtype, and so the compiler is right
to complain.That is correct, however, since MyClass is abstract I will only ever assign a subtype.
More specifically the offending line is
"this.state.setOwner(this);"
where:
- "this.state" is of type T, and the setOwner()
method, according to your definition of class State,
thus expects a type T
- "this" is of type MyClass<T>
Your class type parameter says precisely "T extends
MyClass<T>", in other words T is a subtype of
MyClass<T>. You are thus not allowed to assign a
MyClass<T> instance where a T instance (or a subtype
of T) is expected.Yep, "this" is MyClass<T> at the moment, however it will be of type MyClassSub extends MyClass<MyClassSub> etc, when it actually executes. The reason I am doing this is because I have a few subclasses of MyClass.
So, I would rewrite MyClass definition as follows:
public abstract class MyClass <T extends MyClass<T>>
private State<MyClass<T>> state;
public void setState(State<MyClass<T>> state) {
this.state = state;
this.state.setOwner(this);
See that I use the proper instantiation of generic
State class, by using State<MyClass<T>>This works ok, however, it might as well not use generics since the State class would only ever allow the class MyClass and not a subtype as I wanted in the first place. i.e, I would like to have State class specific to each subtype: e.g, State<MyClassSub1>, State<MyClassSub2>, etc. where MyClassSub1 and MyClassSub2 are subclasses of MyClass<MyClassSub1> and MyClass<MyClassSub2> respectively.