I have a class of 'Character', Character is non-static. I want my player class to extend Character but to also be static.
I basically want all other objects and classes to be able to access player without having to create and pass a player instance.
What's the best why to achieve this?
The only nice way I can think of is actually not an extension but a wrapper:
class Player {
private final static Charachter me = new Character();
public static doSomething(){ me.doSomething(); }
}
Of course you can also extend AND wrap:
class Player extends Character {
private final static Player me = new Player();
// if you don't want anyone creating player objects
// make the constructor private:
private Player(){ super(); }
public void doSomething(){
// stuff
}
public static void staticDoSomething(){ me.doSomething(); }
}
Or, actually, since your goal is just to guarantee that there is a single player object, you can forget about making the methods static, but hide the constructor(s):
class Player extends Character {
private static Player thePlayer = null;
public static Player getPlayer(){
if( thePlayer == null ){
// Create the player
thePlayer = new Player();
}
// There is a valid player object, so return it.
return thePlayer;
}
// hide the constructor(s) by making them private:
private Player(){ super(); }
}
That ensures that the only way to get a Player is to call Player.getPlayer(), and that it always gives you the same object (you never create more than one).
Really it seems like you just want a global variable. This is often accomplished through the Singleton pattern:
public class Player extends Character {
private static final Player humanPlayer = new Player();
private Player() {
}
public static Player getHuman() {
return humanPlayer;
}
//...
}
//...
Player.getHuman().move(2);
There should be very little need for those methods in Player to be static. You're sacrificing good design for a tiny bit of convenience (that will probably bite you later anyway).
Personally I favour dependency injection over global state about 95% of the time. When a method needs to have access to the player, pass it in. That will let you test your code much more easily and will make your code more conducive to change.
Player.getHuman()