Newsgroup: it.comp.java
Titolo: [?] Le interfaccie

Ciao a tutti,
mi sono accorto di aver capito poco delle interfaccie.
Vorrei che ad un certo punto dell'esecuzione, una classe MAnager lanci
un metodo calcolaEqui che pero' puo' essere implementato come meglio si
crede, l'importante e' che riceva un determinato input e ritorni un det.
output.
Ora mi son detto, qui ci vuole una interfaccia: cioe'  tu la classe la
fai come vuoi pero' deve esserci il metodo calcolaEqui.
Qui viene il dubbio...
class Manager{
....
	(?cosa ci metto?).calcolaEqui();
....
}
il nome della classe devo passarglela in input a MAnager?
Ma per tanto cosi' evito di fare l'interfaccia e in Manager metto le
righe
Equilibrium e=new Equilibrium();
Equilibrium.calcolaEqui()
e quindi chi vuole definire come calcolare l'equilibrio deve
implementare una classe chiamata Equilibrium e deve esserci un metodo
chiamato calcolaEqui.
(evitando cosi' le interfacce ma vincolando anche sul nome della classe)
Grazie a chi vorra aiutarmi.
MAssimo.

 writes:
CM> Ciao a tutti,
CM> mi sono accorto di aver capito poco delle interfaccie.
CM> Vorrei che ad un certo punto dell'esecuzione, una classe MAnager lanci
CM> un metodo calcolaEqui che pero' puo' essere implementato come meglio si
Crei  un'interfaccia,  Equilibrabile,  con  il  metodo  calcolaEqui(),
quindi crei delle classi  che implementino Equilibrabile (e che quindi
abbiano calcolaEqui) e in Manager metti:
classe Manager {
...
    public void equilibra(Equilibrabile coso) {
	...
	coso.calcolaEqui();
	...
    }
}
Un  interfaccia   è  un  contratto   che  una  classe  si   impegna  a
rispettare.  Se  la   classe  Ruota  implementa  Equilibrabile  allora
garantisce che ci sia il  metodo calcolaEqui() e quindi il compilatore
è sicuro che definendo una  variabile di tipo Equilibrabile essa possa
avere  riferimenti  solo  ad  oggetti  di tipi  che  hanno  il  metodo
calcolaEqui() nella loro implementazione.
Le varie classi  possono non aver nulla  a che fare con le  une con le
altre. Basta che implementino calcolaEqui().
--
Gian Uberto| main(){printf(&unix["\021%six\012\0"],(unix)["have"]+"fun"-0x60);}
Lauri      |                        David Korn, 1987 ioccc best one liner 
(aka saint)|-------------------------------------------------------------------
em@ail: 
sa...@eng.it
 ( vedere X-nospam nello header - see X-nospam in header )

 
Ok ora e' un po' piu' chiaro pero ' nel main di manager io dovro ad un
certo punto scrivere:
	equilibra(new Ruota());
e quindi MAnager e' dipendente dalla classe che veramente implementa
calcolaEqui(). Mi piacerebbe scrivere Manager in modo che nessuno debba
"toccarla" per far girare la propria inplementazione di calcolaEqui().
Probabilmente Manager deve chiedere in input il nome della classe che
implementa calcEq() e quindi scrivere nel main di Manager:
 
	Class tmp=Class.forName("Stringa in input");
	equilibra((Equilibrabile)tmp.newIstance());
So stato abbastanza confusionale?
Grazie cmq.. mi hai aperto nuovi orizzonti.
MAssimo.

Canonico Massimo wrote:

Vediamo se posso esserti di aiuto.
Se ho capito bene, tu vuoi rendere la classe Manager indipendente dalla classe
che implementa l'interfaccia.
Per far questo è necessario creare una superclasse per Ruota (esempio SuperRuota)
e passare in input alla funzione main() un indice numerico e scrivere le seguenti
istruzioni:
SuperRuota[] pippo
pippo[0] = new Ruota1();
pippo[1] = new Ruota2();
pippo[2] = new Ruota3();
equilibra(pippo[argomento numerico passato in input]);
Nella classe SuperRuota() deve essere inserito un metodo vuoto chiamato
calcolaEqui() con la stessa signature.
All'interno della funzione equilibra() avverrà il processo del Binding Dinamico e
secondo le regole O.O.P. verrà eseguito il codice calcolaEqui() dell'oggetto
istanziato.
CIAO!

Canonico Massimo wrote:

Se ho capito bene, tu vuoi rendere la classe Manager indipendente dalla classe
che implementa l'interfaccia.
Per far questo è necessario creare una superclasse per Ruota (esempio SuperRuota)
e passare in input alla funzione main() un indice numerico e scrivere le seguenti
istruzioni:
SuperRuota[] pippo
pippo[0] = new Ruota1();
pippo[1] = new Ruota2();
pippo[2] = new Ruota3();
equilibra(pippo[argomento numerico passato in input]);
Nella classe SuperRuota() deve essere inserito un metodo vuoto chiamato
calcolaEqui() con la stessa signature. Naturalmente sarà la superclasse ad
implementare l'interfaccia. L'implementazione si estenderà a tutte le sue
sottoclassi.
