ereditarietà

[cigiri18]

buona sera a tutti!
mi scuso per il titolo del topic ma non sapevo cosa altro scrivere, l'ereditarietà è la cosa che si avvicina di più al mio problema(non sapendo come definirlo non ho nemmeno saputo cosa cercare, mi scuso se si era già trattato l'argomento).
date le classi(nomi improvvisati giusto per provare a render meglio il problema

class Giocatore
{   public void update(int elapsedTime);
}
class GiocatoreNelMenu extends Giocatore
{   public void update(int elapsedTime);
}
class GiocatoreNelloScontro extends Giocatore
{   public void update(int elapsedTime);
}

Giocatore contiene i dati del Giocatore(un'istanza per ogni omino sullo schermo)
GiocatoreNelMenu, update(int elapsedTime) deve aggiornare la situazione quando sto lavorando in un menù
GiocatoreNelloScontro, update(int elapsedTime) si occupa di aggiornare i dati quando sta effettivamente giocando

quel che vorrei fare è questo: creare una sola variabile Giocatore, contenente i dati, quindi usare i metodi update delle due sottoclassi, nel senso:
Giocatore g = new Giocatore();
GiocatoreNelloScontro gs = (GiocatoreNelloScontro) g;
GiocatoreNelMenu gm = (GiocatoreNelMenu) g;
questo non funziona per ovvi motivi.

l'unica soluzione che sono riuscito a pensare è eliminare l'ereditarietà e passare nel costruttore delle due sottoclassi l'istanza di Giocatore, da salvare in una variabile all'interno della sottoclasse.

esiste una soluzione più bella e agevole? è ancora in fase di progettazione, quindi non ho limiti alle modifiche alla struttura del programma.
grazie a tutti.

[Patrick Jane]

Come le hai scritte sembrano più annidate... in modo strano.


Certo che esiste comunque. Puoi... sfruttare l'ereditarietà!

Giocatore può contenere sia oggetti di tipo GiocatoreNelMenu sia oggetti di tipo GiocatoreNelloScontro (poichè è la loro superclasse)

Più precisamente, puoi sfruttare il polimorfismo per richiamare i metodi, in questo modo:

class Giocatore {   
  
  public void update(int elapsedTime) {
    System.out.println("Update Giocatore "+elapsedTime);
  }
}
class GiocatoreNelMenu extends Giocatore {   

  public void update(int elapsedTime) {
    System.out.println("Update GiocatoreNelMenu "+elapsedTime);
  }
}

class GiocatoreNelloScontro extends Giocatore {   
  public void update(int elapsedTime) {
    System.out.println("Update GiocatoreNelloScontro "+elapsedTime);
  }
}

class TestE {
  public static void main(String[] args) {
    Giocatore g;
    
    g = new Giocatore();
    g.update(1);
    
    g = new GiocatoreNelMenu();
    g.update(2);
    
    g = new GiocatoreNelloScontro();
    g.update(3);
  }
}

Output:

Update Giocatore 1
Update GiocatoreNelMenu 2
Update GiocatoreNelloScontro 3

Attento però! Se una delle altre classi definisce dei propri metodi, non puoi (e non conviene) fare in questo modo.

In altre parole, se tu fai ad esempio questa aggiunta:

class GiocatoreNelloScontro extends Giocatore {   
  public void update(int elapsedTime) {
    System.out.println("Update GiocatoreNelloScontro "+elapsedTime);
  }
  
  public void altroUpdate() {
    System.out.println("Update di GiocatoreNelloScontro");
  }
  
}

e questa:

    g = new GiocatoreNelloScontro();
    g.update(3);
    g.altroUpdate();

Java segnala un errore di compilazione, poichè altroUpdate() non esiste.

in sintesi, detto in parole molto spicce: le chiamate ai metodi vengono risolte grazie al tipo di oggetto a cui fai riferimento (Giocatore, nel nostro caso); essendo legato in termini di ereditarietà con altre classi, queste classi, se definiscono un metodo uguale a quello della superclasse (update(), nel nostro caso), chiamano il metodo facendo riferimento all'oggetto a cui si riferisce (e non al suo tipo... quindi a quello che crei con new). Questo si chiama Override.

Per essere certo di richiamare altroUpdate() su GiocatoreNelloScontro(), devi per forza castarlo a GiocatoreNelloScontro.


PS: Scusa se ho usato frasi un poco sconnesse, ma questa sera sono molto stanco.

[cigiri18]

Grazie della risposta!
Però non è proprio quel che cercavo, questa sarebbe la seconda o terza scelta per quello che avevo intenzione di fare.
citando il tuo codice, il problema è questo

class TestE {
  public static void main(String[] args) {
    Giocatore g;
    
    g = new Giocatore();
    g.update(1);
    
    g = new GiocatoreNelMenu();
    g.update(2);
    
    g = new GiocatoreNelloScontro();
    g.update(3);
  }
}

vorrei creare un solo oggetto, e usarlo quindi in modi diversi a seconda dell'uso che ne devo fare.
è una cosa abbastanza strana e me ne rendo conto, però mi sarebbe abbastanza comoda.
grazie ancora

[Patrick Jane]

Allora citando il mio codice sopra, non ti resta che utilizzare l'oggetto della superclasse. In questo modo hai accesso a tutti i metodi delle sottoclassi.

Se spieghi meglio che hai in mente, forse possiamo darti aiuti più mirati.

[cigiri18]

più passa il tempo, più mi convinco sia una cosa inutile.
quel che vorrei fare io è qualcosa del tipo:

class Giocatore {

public void update(int elapsedTime) {
System.out.println("Update Giocatore "+elapsedTime);
}
}
class GiocatoreNelMenu extends Giocatore {

public void update(int elapsedTime) {
System.out.println("Update GiocatoreNelMenu "+elapsedTime);
}
}

class GiocatoreNelloScontro extends Giocatore {
public void update(int elapsedTime) {
System.out.println("Update GiocatoreNelloScontro "+elapsedTime);
}
}

class TestE {
public static void main(String[] args) {
Giocatore g;

g = new Giocatore();
g.update(1);
GiocatoreNelMenu gm = g;
gm.update(2);
GiocatoreNelloScontro gs = g;
gs.update(3);
}
}

output:
Update Giocatore 1
Update GiocatoreNelMenu 2
Update GiocatoreNelloScontro 3

insomma vorrei che in condizioni particolari la mia classe si comporti in modi significamente differente rispetto il comportamento ordinario.