Java Generics Problem

[leroy tsruya]

Hi all!
I have a question about generics.
I am trying to create a generic state machine.
so these are the classes:

//The State interface
public interface State<T extends BaseClass> {
   enterState(T t);
   exitState(T t);
}

//a state machine class. an Object of that class should be in any BaseClass Instance.
public class StateMachine<T extends BaseClass> {
   private T owner;
   private State<T> currentState;
   
   public StateMachine(T owner){
      this.owner = owner;
      this.currentState = null;
   }
}


class BaseClass {
   private String name;
   private StateMachine<? extends BaseClass> states;

   public void setState(StateMachine<? extends BaseClass> state){
        this.states.setCurrentState(state);
}

public interface SampleChild1State1 implements State<SampleChild1> {
  //implementation....
}

class SapmleChild1 extends BaseClass{
  public SampleChild1(){
     this.setState(SampleChild1State1);
  }
}


class SampleChild2 {
     //......
} 

The problem is with SampleChild1 class.
whenever I try to pass a SampleChild1State1 Object into the setState method of BaseClass I get the following error:

The method setState(State<capture#2-of ? extends BaseClass>) in the type StateMachine<capture#2-of ? extends BaseClass> is not applicable for the arguments (SampleChild1State1)

Is there anyway to solve this problem? to make my StateMachine class generic so I can declare it only in BaseClass?
Or I will have to have a new specific Object of StateMachine class in any subclass of Baseclass?

Thanks!

[Rob Spoor]

Shouldn't SampleChild1 extend BaseClass?

[leroy tsruya]

Wow.. what a dumb mistake..
Thanks a lot Rob Prime.
it should extend it.

public class SampleChild1 extends BaseClass {
  ...
}

It was a mistake when I typed the post into the site..
I edited the original post as well
Thanks..

[Virendrasinh Gohil]

leroy tsruya wrote:

public interface SampleChild1State1 implements State<SampleChild1>

Many problems with this sample.

1. SampleChild1State1 is interface? If so, it must extend State interface if not, must defined as class
2. SampleChild1 must extend BaseClass (as State interface can only accept <T extends BaseClass>)

  public void setState(StateMachine<? extends BaseClass> state)   

3. The setState method is expected to accept object of StateMachine of type T which extends BaseClass only. Whereas, you are trying to pass SampleChild1State1 which is (if a class) implementation of State itself.

[Rob Spoor]

Leroy, please PostRealCode. You may choose to omit parts that aren't necessary, but with your current code I have to fix too many compiler errors before I get to the error you get (actually I'm not even there yet).

[leroy tsruya]

Rob Prime, once again you are right..
really sorry for the inconvenience...
Here is the code I have, I omitted unrelevant stuff:

package game;

public abstract class BaseGameEntity{
	
	//class member
	private static long nextValidId = 0;
	//this entity's unique id
	private final long id;
	//the state machine for this entity
	protected EntityStateMachine<? extends BaseGameEntity> states;
	public BaseGameEntity(){
		//valid id's start at 1
		nextValidId++;
		//set this entity's id
		this.id = nextValidId;
		//currently the state machine is null
	}
	
	//return this entity's id
	public long getId(){
		return this.id;
	}
	
	public abstract void update();
	
}

package game;

public abstract class InfObject extends BaseGameEntity {

	//this object's name and description
	private final String name;
	private final String desc;
	
	public InfObject(String name, String desc){
		super();
		this.name = name;
		this.desc = desc;
	}
	
	public String getName(){
		return this.name;
	}
	
	public String getDescription(){
		return this.desc;
	}
	
	public String toString(){
		return
		"\nName: " +
		this.getName() +
		"\nDescription: " +
		this.getDescription() +
		"\n";
	}
}

package game;

//state interface for entities
public interface EntityState<T extends BaseGameEntity> {
	void enterState(T t);
	void executeState(T t);
	void exitState(T t);
}

package game;

public class EntityStateMachine<T extends BaseGameEntity> {
	
	private T owner;
	private EntityState<T> currentState;
	private EntityState<T> previousState;
	private EntityState<T> globalState;
	
	public EntityStateMachine(T owner){
		this.owner = owner;
		this.currentState = null;
		this.previousState = null;
		this.globalState = null;
	}
	
	public void setCurrentState(EntityState<T> s){
		this.currentState = s;
	}
	
	public void setGlobalState(EntityState<T> s){
		this.globalState = s;
	}
	
	public void setPreviousState(EntityState<T> s){
		this.previousState = s;
	}
	
	public EntityState<T> getCurrentState(){
		return this.currentState;
	}
	
	public EntityState<T> getPreviousState(){
		return this.previousState;
	}
	
	public EntityState<T> getGlobalState(){
		return this.globalState;
	}
	
	public void update(){
		if(this.globalState != null){
			this.globalState.executeState(this.owner);
		}
		if(this.currentState != null){
			this.currentState.executeState(this.owner);
		}
	}
	
	public void changeState(EntityState<T> newState){
		if(newState == null){
			System.out.println("Error, attempt to assign null state as new state!");
		}
		else {
			this.previousState = this.currentState;
			this.currentState.enterState(this.owner);
			this.currentState = newState;
			this.currentState.enterState(this.owner);
		}
	}
}

package rpg;

import game.InfObject;
import game.EntityStateMachine;

public abstract class Item extends InfObject{

	protected int itemBaseValue;
	//protected EntityStateMachine<Item> states;
	
	protected Item(String itemName, String itemDescription, int itemBaseValue){
		super(itemName, itemDescription);
		this.itemBaseValue = itemBaseValue;
		this.states = new EntityStateMachine<Item>(this);
                                 this.states.setCurrentState(new ItemUnidentifiedState());
	}
	
	protected int getBaseValue(){
		return this.itemBaseValue;
	}
	
}

package rpg;

import game.EntityState;
public class ItemUnidentifiedState implements EntityState<Item>{
	
	public void enterState(Item item){
	}
	public void executeState(Item item){
		
	}
	public void exitState(Item item){

	}
}

This is what I get:

The method setCurrentState(EntityState<capture#2-of ? extends BaseGameEntity>) in the type EntityStateMachine<capture#2-of ? extends BaseGameEntity> is not applicable for the arguments (ItemUnidentifiedState)

[Rob Spoor]

OK, now I could pinpoint the exact location of the error.

"this.states" is an EntityStateMachine<? extends BaseGameEntity>. And that wildcard is the problem. EntityStateMachine<T> expects a T for its setCurrentState method. However, what is T in this.states? You don't know. It could be BaseGameEntity, InfObject, or anything else that extends BaseGameEntity.

I suggest you make BaseGameEntity generic as well. The class definitions then become as follows:

abstract class BaseGameEntity<T extends BaseGameEntity<T>> // looks scary but it really isn't
abstract class InfObject<T extends BaseGameEntity<T>> extends BaseGameEntity<T> // simply copy the bounds and pass along
interface EntityState<T extends BaseGameEntity<?>> // the type doesn't matter, does it?
class EntityStateMachine<T extends BaseGameEntity<?>> // likewise
abstract class Item extends InfObject<Item> // Item now indirectly extends BaseGameEntity<Item>

One more change is required, in BaseGameEntity:

    protected EntityStateMachine<T> states; // uses T

This now matches the initialization of states inside Item:

        this.states = new EntityStateMachine<Item>(this); // T == Item

After these changes I could compile your code.

[leroy tsruya]

Wow! Thanks Rob!
It compiles now! No errors at all
However, can you please explain what that line of code means:

abstract class BaseGameEntity<T extends BaseGameEntity<T>> 

And also, if I may.. Is that the best way to do it?
Or, did I complicate it more than it should be?

[Rob Spoor]

The other alternative is to use

protected EntityStateMachine<BaseGameEntity> states;

I haven't tested if that would compile. If so, that would actually be easier.

As for that line. The T is the new generic type, as usual. Because you had "? extends BaseGameEntity" the T must be bound as well. That would lead to "T extends BaseGameEntity". However, BaseGameEntity is now generic, so the compiler will complain about a raw type. You must fill in the generic type. There are actually more alternatives:
- BaseGameEntity<?> -- any BaseGameEntity is allowed. This would allow Item to extend InfObject<BaseGameEntity>, InfObject<InfObject>, InfObject<Item>, or any other sub class of BaseGameEntity.
- BaseGameEntity<T> -- Item can only extend InfObject<Item>
- BaseGameEntity<? extends T> -- Item can only extend InfObject<Item> and InfObject<X> where X is any sub class of Item
- BaseGameEntity<? super T> -- like ? but limited to BaseGameEntity, InfObject and Item
- BaseGameEntity<X> with X being a hard coded class. You definitely do not want that though.


I think that trying out to remove the "? extends" from states would actually be worth checking out. It will make your classes less complex.

[leroy tsruya]

Thanks all for the help, especially Rob, you have been a great help for me.
It works perfect now, and I updated other classes I wrote.
Unfortunately, your suggestion seems the only way the code will compile.
Thanks a lot