[JAVA] Dynamic Dispatch con due gerarchie di classi

[Tallid]

Dydnamic Dispatch
date 2 gerarchie di classi:
Ant extends Creature, Troll Extends Creature
e
AntPotion extends Potion,TrollPotion extends Potion
rappresentare il fatto che diversi tipi di pozioni hanno diversi eetti sui diversi tipi
di creature
codice:

class Potion {
      public void spray( Creature aCreature ) { . . . }
. . . }

e realizzando l'implementazione in modo che il metodo si comporti diversamente a seconda
del tipo di pozione e della creatura.
Completate l'implementazione della classe Potion e di tutte le classi della gerarchia in modo
da ottenere l'effetto desiderato, senza utilizzare il predicato instanceof (nessun testcase sui tipi di oggetto)

esempio:
codice:

Potion container = null; 
Creature aCreature = null; 
// test Potion on different creatures 
container = new Potion(); 
aCreature = new Creature(); 
container.spray( aCreature ); 
aCreature = new Troll(); 
container.spray( aCreature ); 
aCreature = new Ant(); 
container.spray( aCreature ); 
// test TrollPotion on different creatures 
container = new TrollPotion(); 
aCreature = new Creature(); 
container.spray( aCreature );
 aCreature = new Troll();
 container.spray( aCreature ); 
aCreature = new Ant(); 
container.spray( aCreature ); 
// test AntPotion on different creatures 
container = new AntPotion(); 
aCreature = new Creature(); 
container.spray( aCreature ); 
aCreature = new Troll(); 
container.spray( aCreature ); 
aCreature = new Ant(); 
container.spray( aCreature );

produce l'output:

Potion sprayed on Creature
Potion sprayed on Troll
Potion sprayed on Creature
TrollPotion sprayed on Creature
TrollPotion sprayed on Troll
TrollPotion sprayed on Creature
AntPotion sprayed on Creature
AntPotion sprayed on Troll
AntPotion sprayed on Creature

ho definito
codice:

class Ant extends Creature {}
class Troll extends Creature {}
class AntPotion extends Potion{
       
        public void spray(Creature c){
             //print AntPotion on Creature
        }
        public void spray(Ant a){
             //print AntPotion on Ant
        }
}
class TrollPotion extends Potion{
        
        public void spray(Creature c){
             //print TrollPotion on Creature
        }
        public void spray(Troll a){
             //print TrollPotion on Troll
        }

}

ma l'output dato è:
POZIONE on CREATURA
POZIONE on CREATURA
POZIONE on CREATURA
TROLL POTION on CREATURA
TROLL POTION on CREATURA
TROLL POTION on CREATURA
ANT POTION on CREATURA
ANT POTION on CREATURA
ANT POTION on CREATURA

sembra che il tipo dinamico di Potion sia rilevato e quindi richiamato l'opportuno metodo della sotto classe,ma il Best Match di sparay con parametro Creature,Troll,Ant è comunque quello con Creature.
Qualcuno è in grado di aiutarmi? Grazie

[andbin]

Originariamente inviato da Tallid
Qualcuno è in grado di aiutarmi? Grazie

Non ho letto tutto tutto perché è un po' lungo ma vedendo le invocazioni (il secondo pezzo di codice) posso dirti questo.

Tutte le invocazioni di spray che hai fatto sono effettuate su un reference di tipo Potion (il tipo base delle pozioni), intendo proprio dire la variabile che hai messo all'inizio:

Potion container = null;

Quindi la versione di spray che il compilatore conosce e usa per la invocazione è solo e unicamente quella:

public void spray(Creature)
di Potion.

Poi la implementazione realmente usata a runtime dipende dall'oggetto effettivamente assegnato a container.

Quindi quando a container assegni un TrollPotion, allora a runtime verrà usato il:

public void spray(Creature)
di TrollPotion

E idem per AntPotion.

Questo è quello che succede con il tuo codice.

[progAnd]

Qual'è il comando che viene usato per stampare l'output? Non l'ho trovato nel codice postato...

Ciao

[Tallid]

Ciao

Si il comando è il System.out.println("Pozione on Creatura");

dove Pozione è sostituito da AntPotione nella sottoclasse AntPotion
e da TrollPotione in TrollPotion

[Tallid]

Grazie per le risposte,
Come faccio quindi a richiamare il metodo spray della sottoclasse TrollPotion con parametro di tipi Troll?ossia stampare "TrollPotion on Troll"?

[andbin]

Originariamente inviato da Tallid
Come faccio quindi a richiamare il metodo spray della sottoclasse TrollPotion con parametro di tipi Troll?ossia stampare "TrollPotion on Troll"?

Ma hai capito quello che ho detto io? Che è poi la spiegazione, tramite esempio con tuo codice, di come funziona una invocazione "virtuale" dei metodi in Java.

La questione è: in Potion hai solo il spray(Creature) ?

Hai chiaro il fatto che spray lo invochi su una variabile di tipo Potion e il compilatore "guarda" solo in Potion per valutare quale versione di spray usare? (e non conta per il compilatore cosa assegni a container

[Tallid]

Allora:
1)Si in Potion ho solo quel metodo che fa spray su una creatura generica
2)Forse non mi sono spigato bene

A me non interessa cosa fa il compiler.
A runtime il mio codice riesce a differenziare le varie pozioni,infatti, l'output che viene generato dal mio codice (come avrai notato) dice "TROLL POTION ON CREATURA" quando nel container c'è
container=new TrollPotion() e quindi è corretto dire che va a guardare nella sottoclasse.
Il problema sta nel differenziare le creature ossia:
quando viene chiaato il emtodo spray su un Potion container=new TrollPotion() e una Creature creatura=new Troll() venga richiamata la funzione spary all'interno di TrollPotion che ha come parametro in ingresso un Troll

[andbin]

Originariamente inviato da Tallid
1)Si in Potion ho solo quel metodo che fa spray su una creatura generica

Ok ma l'avevo immaginato.

Originariamente inviato da Tallid
A me non interessa cosa fa il compiler.

E invece ti deve interessare, perché altrimenti non capisci/ha capito cosa succede prima in compilazione e poi successivamente a runtime.

Originariamente inviato da Tallid
A runtime il mio codice riesce a differenziare le varie pozioni

Perché in ogni pozione specifica (sotto-tipo di Potion) hai fatto un "override" di void spray(Creature).
E questa è l'unica cosa che puoi fare per come hai definito le cose.

[Tallid]

Quello che penso accada a compilazione:
il compilatore va a cercare un metodo spray all'interno della classe Potion che riceve in ingresso una Creature e questo accede ogni volta che richiamo il metodo spray.
Questo perchè container è una variabile di "tipo statico" Potion.
Quello che succede a runtime è tutta un 'altra storia:
la variabile container assume il "tipo dinamico" che è dato dall' oggetto che la istanza
ad esempio Potion container =new TrollPotion() la variabile container è "tipo dinamico"=TrollPotion.
Infatti a runtime il codice:
Potion container=null;
container=new TrollPotion();
container.spray(new Creature());
va a cercare un metodo spray(Creature) all'interno della classe TrollPotion producendo l'autpot corretto System.out.println("TrollPotion on Creature").

Mi è stato dato quel codice d'esempio e le gerarchie. A me sta l'implementazione che renda possibile l'output richiesto.

[andbin]

Originariamente inviato da Tallid
Mi è stato dato quel codice d'esempio e le gerarchie. A me sta l'implementazione che renda possibile l'output richiesto.

Le cose stanno così:

1) Se in Potion hai (e continuerai ad avere) solo il metodo void spray(Creature), nelle sotto-classi di Potion, all'interno del metodo in "override" (quindi sempre void spray(Creature)) gli unici modi per "sapere" di che tipo è la creatura sono:
... a) Usare instanceof (ma hai già precisato di non volerlo e anzi presumo, non doverlo usare).
... b) Fare in modo che ogni creatura abbia un metodo es. String getInfo() (in Creature e override nei sotto-tipi), in modo che dato un Creature puoi sapere es. "Troll", ecc..... Ma questo comunque sarebbe discutibile e presumo (dagli obiettivi dell'esercizio) che non è questo che si vuole.

oppure

2) Fare in modo che in Potion ci siano le varie versioni di spray in overload per accettare le varie creature. Chiaramente override per tutti nei sotto-tipi di Potion e ancora più importante, invocando spray su un Potion si deve passare ognuna delle creature facendo in modo che il compilatore capisca che è quel tipo esatto. (non basta avere solo una variabile Creature! altrimenti il compilatore cerca solo un spray(Creature) !)

Scegli tu.