Java: class statica estesa di una class non statica

Ho una class di “Personaggio”, il personaggio non è statico. Voglio che la mia class di giocatori estenda Carattere ma sia anche statica.

Fondamentalmente voglio che tutti gli altri oggetti e classi siano in grado di accedere al player senza dover creare e passare un’istanza giocatore.

Qual è il migliore perché farlo?

L’unico bel modo in cui riesco a pensare non è in realtà un’estensione, ma un involucro:

class Player { private final static Charachter me = new Character(); public static doSomething(){ me.doSomething(); } } 

Naturalmente puoi anche estendere E avvolgere:

 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(); } } 

Oppure, dal momento che il tuo objective è solo quello di garantire che ci sia un object single player, puoi dimenticare di rendere i metodi statici, ma hide i costruttori:

 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(); } } 

Ciò garantisce che l’unico modo per ottenere un Player è chiamare Player.getPlayer() , e che ti dà sempre lo stesso object (non ne crei mai più di uno).

In realtà sembra che tu voglia solo una variabile globale. Questo è spesso ottenuto attraverso il modello Singleton:

 public class Player extends Character { private static final Player humanPlayer = new Player(); private Player() { } public static Player getHuman() { return humanPlayer; } //... } //... Player.getHuman().move(2); 

Ci dovrebbe essere pochissima necessità che quei metodi in Player siano statici. Stai sacrificando un buon design per un minimo di comodità (che probabilmente ti morderà comunque in seguito).

Personalmente preferisco l’iniezione di dipendenza nello stato globale circa il 95% delle volte. Quando un metodo deve avere accesso al lettore, passarlo. Ciò ti permetterà di testare il tuo codice molto più facilmente e renderà il tuo codice più favorevole al cambiamento.