Newsgroup: it.comp.java
Titolo: Assegnazione dinamica di oggetti

Ciao a tutto il NG,
ho un problema che riguarda il casting di oggetti e loro assegnamento.
Mi spiego. Nel mio codice ho due dati:
- Object contenente un oggetto (nativo del JDK o custom)
- String contenente il tipo di oggetto specifico (quello del punto
precedente per intenderci "String", "Float", "Exception"..).
Devo ricreare questi oggetti. Ho pensato alla reflection e, utilizzando il
metodo forName della classe Class ottengo un oggetto che poi "casto"
utilizzando il metodo cast(). Tutto ok, ma ora come posso assegnare in
maniera dinamica questo oggetto castato ad un riferimento del tipo
corretto?
Esempio:
Ho un Object pippo che contiente un riferimento ad una stringa;
Ho una stringa (String valueType) con valore "java.lang.String" (l'esatto
tipo di pippo);
Class c = Class.forName(valueType);
c.cast(pippo);
ora come assegno questo risultato ad un oggetto specifico (nel mio caso
String).
Tutto questo perchè devo richiamare dei metodi in maniera dinamica
passando questi oggetti.
Ho provato a fare anche questo:
nomeMetodoCheAccettaStringComeParametro((c.getClass())pippo);
quindi a effettuare un cast di pippo in maniera dinamica ma non ha
funzionato.
So che la domanda è un po' incasinata e forse non sono stato molto chiaro,
ma ringrazio davvero tutti quelli che mi daranno una mano!!
Grazie a tutti
Luca
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

non so se ho capito,
ma potrebbe tornarti utile la parola chiave instanceof
che ti permette di stabilire il tipo di oggetto.
Es:
class Perepe{
	...
}
in un metodo avendo un oggetto particolare
puoi verificare per esempio
Object pOggetto = new Perepe(...);
if (pOggetto instanceof Perepe)
{
	Perepe tmp = (Perepe)pOggetto;
}
...
ecc ecc
-- 
             {2Nd+BESt}
-----------------------------------
never underestimate human stupidity

 }
Non credo...perchè io non so nemmeno che esiste la classe Perepe!!
Io ricevo un oggetto che potrebbe essere....qualunque cosa e il nome di un
metodo che riceve come parametro quell'oggetto "qualunqe cosa"...lo scopo
è quello di chiamare questo metodo passandogli questo oggetto.
Cmq grazie infinite per l'intervento!!
Ciao


 ha scritto nel messaggio 
news:d9s0kl$img$1...@news.newsland.it...


Cioe' se ho capito, tu vorresti fare una 'roba' del genere:?
String tipo = "java.lang.Integer";
Object intero =  new Integer(4);
tipo nuovoOggetto = (tipo)intero;
Ho capito il tuo pensiero?
Ovvero vuoi che il cast e la tipizzazione della variabile siano
dinamici?
Beh, in java non e' possibile, il compilatore <deve> sapere esattamente
di che tipo (o classe) è una variabile a tempo di compilazione, e se
tu che scrivi il codice non lo puoi sapere allora devi dichiararla
Object.
Qualcosa di simile lo puoi fare con instanceof, oppure con la
reflection, ma allora devi conoscere anche i nomi dei metodi da
chiamare sull'oggetto e la lista dei parametri.
Es:
String tipo = "java.util.ArrayList";
Object obj = new ArrayList();
String metodo = "add";
Object[] listaParametri = {"abc"};
if(obj.getClass().getName().equals(tipo)){
 Method m = obj.getClass().getMethod(metodo);
 m.invoke(obj,listaParametri);
}
Anche se bisognerebbe capire perche' devi incasinarti cosi' la vita....
 
}

 Anche se bisognerebbe capire perche' devi incasinarti cosi' la vita....
eheh...hai PERFETTAMENTE ragione! Il problema è che devo effettuare il
wrapping di una "cosa" non sviluppata da me e soprattutto sviluppata (non
voglio peccare di presunzione) in maniera non molto pulita e ordinata.
Insomma...devo mettere mano a codice non mio, cercare di wrapparlo in
un'architettura più scalabile e visto che le tempistiche , come sempre,
sono strettissime, non c'è possibilità almeno per i primi rilasci di
riscrivere il codice "incriminato".
Cmq, grazie davvero per il tuo intervento, malgrado le brutte notizie mi
ha dato una delucidazione...NON SI PUO' FARE!
Ciao e grazie ancora


Ovviamente dato che non so precisamente com'e' la situazione potrebbe
darsi che quello che ti diro'...
a) non serve
b) ci hai gia' pensato e l'hai scartato...
pero'
Non potresti creare una serie di interfacce che espongono i metodi che
vuoi "wrappare",
poi per quanto riguarda l'implementazione ti fai delle classi che
implementano tali interfacce e che nascondono al loro interno tutto il
porcaio necessario (magari anche serie giganti di if(instanceof...)).
E decidere a runtime quale classe usare di volta in volta
tipo:
interface WrapInterface{
 public int metodoDaEsporre(int a,string b,ArrayList c);
 etc.
}
public class WrapImpl_1 implements WrapInterface{....}
public class WrapImpl_2 implements WrapInterface{....}
e poi nel codice
string classeDaUsare = "WrapImpl_1";
WrapInterface i =
(WrapInterface)Class.forName(classeDaUsare).newInstance();
i.metodoDaEsporre(....)
e a questo punto hai a compile time il type checking sui parametri in
ingresso e in uscita dei metodi...
Io ho detto..
poi magari non si applica al tuo caso...

e provare a tirare in ballo il ClassLoader, o meglio
crearti una classe che estende/implementa il ClassLoader,
o solamente vedere se e' possibile lavorarci su?
non so dirti di piu',
prova a studiarlo un po....
