Newsgroup: it.comp.java
Titolo: Class.forName (o ditemi voi cosa) e... ereditarietà al contrario

Avrei bisogno di passare ad un metodo un oggetto che può appartenere a 
diverse classi (diciamo pippo, pluto e paperino), ma tutte hanno in comune i 
nomi e parametri dei metodi, nonchè delle proprietà. Qualcosa tipo quanto 
riportato in calce. Il problema è che in ingresso dovrei dichiarare il tipo, 
e se dichiaro il tipo pippo [public miometodo(pippo a,int b)] non verrà 
accettato il tipo pluto o paperino, e così via. Se dichiaro Object passa, ma 
perdo proprietà e metodi delle mie classi (esattamente quanto deve essere 
utilizzabile).
C'è modo di realizzare una sorta di ereditarietà al contrario (un tipo di 
classe che possa essere di tipo pippo, pluto o paperino, utilizzandone i 
rispettivi metodi, proprietà e costruttori, e le cui istanze possano essere 
passate a metodi di altre classi?
public class pippo
{
 public int var1;
 public double var2;
 public int[]metodo(int a, int b) {/*ecc.*/}
 public pippo() {/*ecc.*/}//costruttore
}
public class  pluto
{
 public int var1;
 public double var2;
 public int[]metodo(int a, int b){/*ecc.*/}
 public pluto() {/*ecc.*/}//costruttore
}
public class  paperino
{
 public int var1;
 public double var2;
 public int[]metodo(int a, int b){/*ecc.*/}  }
 public paperino() {/*ecc.*/}//costruttore
} 


Creare una classe padre?
public abstract class disney{
	public int var1;
	public double var2;
	public abstract int[] metodo(int a,int b); //magari non astratto se il 
metodo è uno
}
public class paparino extends disney{...}
public class pluto extends disney{...}
public class pippo extends disney{...}
e passi come nome disney?

>Creare una classe padre?
Oppure crei un'interfaccia che dichiara quel metodo, e le tue classi
implementano quell'interfaccia :)

> Creare una classe padre?
B> Oppure crei un'interfaccia che dichiara quel metodo, e le tue
B> classi implementano quell'interfaccia :)
Che  è il metodo  che suggerirei  anche io,  che le  classi potrebbero
discendere da Object per vie diverse.
-- 
 /\            ___
/___/\__|_|\_|__|___Gian Uberto Lauri_____________________
  //--\ | | \|  |   Integralista GNUslamico  
\/		    e allevatore di bug da competizione

 e passi come nome disney?
Ci avevo pensato, quando creo il metodo
miometodo(disney d) {/*...*/}
, se lo richiamo con
pippo p=new pippo({/*...*/);
miometodo(p);
viene passata la struttura della classe disney, perdendo le caratteristiche 
peculiari delle classi figlie, o no? In altre parole i metodi astratti, che 
in disney non sono implementati sono accessibili passando come parametro una 
classe figla di disney in un metodo che si attende disney? 



Visto che le tue classi implementano tutte lo stesso metodo potresti fare
un interfaccia e passare quella al tuo metodo.
Oppure.. sempre se le tue classi hanno un antenato in comune (classe o
interfaccia) diciamo paperone puoi usare i parametri:
la tua classe la dichiari come:
public class TuaClasse<T extends paperone> {...}
e il tuo metodo:
miometodo(T o, int b)
a questo punto se crei un oggetto TuaClasse<pippo> potrai usare il metodo
miometodo(pippo o, int b).. e così via..
-- 
Pietro
(\_/)  <- This is Bunny.
(°_°)     Copy Bunny into your signature to help
(> <)     him on his way to world domination.

 miometodo(pippo o, int b).. e così via..
Dunque, il problema è questo: devo passare una serie di struture 
linguistiche (non solo di frasi preconfezionate, altrimenti le avrei 
inserite in un file txt da leggere, e non in una classe apposita). Solo che 
ho una classe ita e una eng, e devo passare come parametro l'una o l'altra a 
seconda della scelta della lingua. Ora, prevedo in ingresso dei vari metodi 
una classe di tipo ita non verrebbe accettata eng e viceversa, mentre se 
faccio derivare da una classe astratta lingua sia ita che eng e prevedo la 
possibilità di un parametro di tipo lingua in ingresso, quando passo un ita 
viene probabilmente eseguito un casting che mi fa perdere le peculiarità di 
ita, provocando una serie di nullpointer exception.
Penso proprio che mi orienterò diversamente. Grazie dell'aiuto, comunque. 

 
Se ita e eng estendono lingua e hanno lo stesso comportamento allora puoi
tranquillamente passare lingua senza fare nessun cast, e utilizzare i
metodi di lingua (essendo ita e eng due lingue immagino abbiano gli stessi
metodi, no? se non è così allora forse non ha senso fargli estendere la
stessa classe..)
Comunque se tu dichiari la classe:
public class Test<L extends lingua> {
	void miometodo(T o) { }
}
allora nel momento in cui conosci la lingua puoi fare:
new Test<EngClass>.miometodo(eng);


 new Test<EngClass>.miometodo(eng);
No, io volevo selezionare UNA VOLTA PER TUTTE la lingua, caricare le 
strutture linguistiche necessarie, e portarmi appresso quelle. Senza dover 
ogni volta scegliere.
Ho risolto creando una classe che ha ita e eng come campi, istanzia una 
delle due nel costruttore e ricopia in sč i parametri necessari. Con qualche 
switch (neanche troppi), ma funziona.
Grazie, comunque.
Marco 

 qualche switch (neanche troppi), ma funziona.
Lascia perdere questa soluzione che è molto sporca.. lascia fare al
polimorfismo.. gli switch meno ne usi meglio è (come pure per gli IF)


 conseguenza una serie di nullpointer exception.
Questo mi pare poco probabile.
Probabilmente ci sara' un errore da qualche parte.
Saluti
CarMas


No, io credo che sia proprio così.
riepilogando, io devo passare ad una classe (immaginiamo, tanto per 
semplificare, una finestra extends Frame) un elemento di un'altra classe che 
contenga Label e quant'altro (continuo a semplificare).
DEVO prevedere qualcosa tipo new finestra(lingua l), o new finestra(italiano 
i), o new finestra(inglese e).
Nel secondo caso sono costretto a passare il tipo italiano, e inglese non 
verrà accettato; nel terzo al contrario. L'unica possibilità rimane la 
prima, supponendo che italiano e inglese estendano lingua. Come suggerito da 
qualcuno, lingua potrebbe essere una classe astratta, con alcuni metodi 
dichiarati ma non implementati (non sarebbe possibile), mentre l'effettiva 
implementazione avverrebbe nelle classi figlie. Italiano e inglese, per 
l'appunto.
E qui viene il problema. Ho verificato che quando istanzio italiano viene 
eseguito quanto dovuto, p. es. mi ritrovo un Vector con un certo numero di 
componenti non null.
Quando viene passata come parametro a new finestra(lingua l), non appena 
finestra tenta di accedere agli elementi del Vector genera 
nullpointerexception. Io penso che, dichiarando come lingua il parametro in 
entrata, viene passata l'istanza della classe italiano SOLO per quanto 
riguarda le proprietà che ha ereditato da lingua, perdendo TUTTE le proprie 
specificità.
Penso che una classe che contiene italiano e inglese come campi, 
istanziandone uno nel costruttore, sia la strada migliore, nonostante 
servano due o tre switch qua e là.
Ciao
Marco 

 servano due o tre switch qua e là.
Puo' darsi che funzioni, ma sicuramente viene fuori una porcata (scusa 
il termine) di codice.
Il fatto e' che "cosi' funziona" e' decisamente un approccio sbagliato.
Saluti
CarMas

 servano due o tre switch qua e là.
Non fare così... posta il codice e cerca di capire perché la soluzione
migliore non ti funziona.
Stai programmando in Java non in VB....


 Posta il codice che ti da l'errore.
Ho fatto varie modifiche, chi si ricorda più il codice originale... non 
escludo che il problema sia quello indicato da CarMas (variabili 
ridichiarate erroneamente nelle classi figlie). Per il momento come ho 
impostato il problema funziona; quando avrò un attimo di tempo verificherò 
se con una attenta dichiarazione delle variabili è possibile una soluzione 
diversa.
Grazie a tutti.
Marco

 escludo che il problema sia quello indicato da CarMas 
D'altro canto, noi senza vedere nulla possiamo solo immaginare 
(improvvisare?) e quindi non essere molto utili.
Saluti
CarMas

 (improvvisare?) e quindi non essere molto utili.
Per carità, non pretendevo miracoli... già ho avuto qualche indicazione 
utile, ma è anche che nel frattempo ho preso una strada diversa.
Grazie ancora dei suggerimenti, e alla prossima.
Marco