AppletTalk.com

theLuke · Guest

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 [email]abuse (AT) newsland (DOT) it[/email]

{2Nd+BESt} · Guest

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

theLuke · Guest

{2Nd+BESt} ha scritto:

Ferreri Gabriele · Guest

Forse è una cosa stupida, ma perchè invece di tutto questo non passi al
metodo un Object e poi il metodo si occupa di fare il Cast???

"theLuke" <fafiox (AT) libero (DOT) it> ha scritto nel messaggio
news:d9s0kl$img$1 (AT) news (DOT) newsland.it...

iomcenter-giginus@yahoo.i · Guest

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....

}

theLuke · Guest

[email]iomcenter-giginus (AT) yahoo (DOT) it[/email] ha scritto:

iomcenter-giginus@yahoo.i · Guest

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...

{2Nd+BESt} · Guest

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....

--
{2Nd+BESt}
-----------------------------------
never underestimate human stupidity