Newsgroup: it.comp.java
Titolo: Aiuto: Creare una nuova istanza di una classe col metodo newInstance( )

Salve,
qualcuno può darmi una mano a risolvere questo problema?
Il nome della classe da istanziare è contenuto in una stringa  il cui
valore non è noto a priori ma run-time, poichè esso è restituito da un
metodo, ad esempio
String s = getName();
A questo punto creo l'oggetto in questo modo
Object miaClasse = Class.forName(s).newInstance();
ma qui sorge il problema.
Essendo miaClasse di tipo Object, non riesco ad invocare nessun metodo
appartenente a miaClasse.
Ho pensato di fare un'operazione di cast, ma non sono riuscito a
trovare una soluzione flessibile da utilizzare run-time.
Ringrazio in anticipo chiunque possa darmi una mano.
C.Z.

 wrote in message
news:3c4edf8...@news.polito.it...


e su var chiami i metodi che ti servono
Provo subito!
Grazie mille per l'attenzione e per la rapidità della risposta.
Ciao.
C.Z.

appartenente a miaClasse.
La via più complessa e completa potrebbe essere usare la reflection
import java.lang.reflect.*;
public class TestReflection
{
	public static void main(String[] args)throws Exception
	{
		Class myClass=Class.forName("TestReflection");
		// la classe che voglio istanziare
 
		Object myInstance=myClass.newInstance();
		// ecco l'istanza
 
		Class[] paramTypes={String.class};
		// i tipi dei parametri del metodo che voglio invocare
 
		Method myMethod=
			myClass.getMethod("testMethod",paramTypes);
		// il metodo che voglio invocare
 
		Object[] params={"test"};
		// i parametri che voglio passare al metodo
 
		myMethod.invoke(myInstance,params);
		// ora invoco il metodo
	}
 
	public void testMethod(String param)
	{
		System.out.println(param);
	}
}
Good luck,
Mauri.
-- 
La forza di gravità è un falso mito,
è la Terra che succhia!

trovare una soluzione flessibile da utilizzare run-time.
La flessibilità ha ovviamente un limite, ed è dato dal fatto che tu
almeno devi in qualche modo conoscere i metodi che vuoi chiamare a
runtime. Ti potrei consigliare di guardare il package
java.lang.reflect, ma secondo me è sbagliato il modello che stai dando
al tuo programma.
La soluzione corretta è definire un interfaccia, tutte le classi che
intendi creare a runtime implementano quell'interfaccia. A runtime tu
fai il cast a quella interfaccia (meglio ancora se implementi il
pattern factory). 
Uno degli aspetti più interessanti di java è il concetto di
riusabilità dei modelli (pattern), che sicuramente non è legato al
linguaggio ma che in java è usato con regolarità. Spesso quando si
cerca una soluzione ad un problema basta chiedersi a quale modello si
adatta, dopodichè si implementa quel modello. O più semplicemente si
può vedere come implementano gli altri il tuo stesso problema o
problemi analoghi (in sostanza, istanziare una classe di cui non si è
nota l'implementazione a runtime) addirittura nel jdk, potrai notare
una notevole omogeneità di soluzioni. Il concetto è quello di non
reinventare ogni volta l'acqua calda e soprattutto implementare
modelli di soluzioni collaudati (magari anche a modesto scapito della
flessibilità... la quale oltre un certo limite diventa un difetto
anzichè un pregio).
Il consiglio che voglio darti è dare un'occhiata ai pattern (su
internet e in bibliografia).
if(!spammer)
for(ptr=email;*ptr!='\0';ptr++) 
if(*ptr!='@' && *ptr!='.') *ptr -= 1;


Darò un'occhiata  quindi anche a questa!
Grazie mille.
C.Z.

pattern factory). 
Cercherò di mettere insieme tutti i consigli che mi avete dato.
L'idea dell'utilizzo di interfacce è la via che mi sembra migliore,
visto soprattutto il caso mio, comunque un'approfondimento della
"reflection" potrebbe risultarmi molto utile in futuro.
Grazie mille per l'aiuto.
C.Z.