[JAVA] creare un oggetto...

[DesmoColo]

Un altra questione un "strana":
Class temp = UnAltraClasse.forName();

come faccio a creare un oggetto di tipo temp?

[DesmoColo]

Ho appena risolto:
basta fare
Object mioObj = temp.newIstance();

Cmq non è ancora finita: come faccio a passare ad mioObj un parametro "manualmente" per inizializzarlo con un parametro ben preciso? Spero di essermi spiegato...

[tglman]

penso che questi link ti siano sufficenti per autodarti tutte le risposte ;-)
Class
Field
Method
Constructor


Ciao!!

[-fidel-]

Originariamente inviato da DesmoColo

Ho appena risolto:
basta fare
Object mioObj = temp.newIstance();

Cmq non è ancora finita: come faccio a passare ad mioObj un parametro "manualmente" per inizializzarlo con un parametro ben preciso? Spero di essermi spiegato...

Object mioObj = new temp(param1,...,paramn)

ovviamente il costruttore della classe 'temp' deve essere coerente con i parametri passati.

[DesmoColo]

Dopo averci pensato un giorno e una notte forse ho concluso qualcosina. Per motivi legati all'aplìplicazione che sto costruendo ho affidato il lavoro "sporco" a un thread apposito. Il Thread è così concepito:
il suo costruttore prende in ingresso una stringa (es: "provaBuildAttore");
Da questa stringa, costruisce due file:
provaBuildAttore.java e provaBuildAttoreAdapter.java con i metodi della classe FileWriter;
Un processo compila i due sorgenti;
il thread crea un oggetto actor di tipo provaBuildAttore
Se tutto va bene voglio che il Thread alla fine generi la seguente cosa:
provaBuildAttoreAdapter pbaa = new provaBuildAttoreAdapter(actor);
Visto che fino ad oggi non avevo mai usato i metodi della reflection (Anzi, mi sto stupendo di quanto sia potente ed efficace, per lo meno per quello che sto facendo!!!) vorrei sapere se il codice del run() del Thread è corretto. Il codice è il seguente:


import java.io.*;
import java.lang.reflect.*;
public class ThreadRuntime implements Runnable{

private String nameclass;
private Object oggettoRestituito;
public ThreadRuntime(String s){

nameclass = s;
}
public void setObject(Object o){
oggettoRestituito = o;
}
public Object getObject(){
Thread trt = new Thread(this,"ThreadName");
trt.start();
return oggettoRestituito;
}
public static Class getClass(Class c){
Class classe = null;
try{
classe = (Class)c.newInstance();
}catch(Exception e){}
return classe;
}
public void run(){

Object oggettoAttore = null;

Class attore = null;
Class attoreAdapter = null;

boolean checkpoint = false;

String rAdapter = nameclass.concat("Adapter");


String nomeFile= "public class "+nameclass + " extends Actor{public "+ nameclass+"(){};}";
String nomeFileAdapter = "import java.awt.event.*; public class " +nameclass+"Adapter extends KeyAdapter{private " +nameclass +" attore; public "+ nameclass+"Adapter("+nameclass+" a){attore = a;}}";
try{

FileWriter nomeF = new FileWriter(nameclass+".java");
FileWriter nomeFA = new FileWriter(nameclass + "Adapter.java");

char[] arrayNomeFile = nomeFile.toCharArray();
char[] arrayNomeFileAdapter = nomeFileAdapter.toCharArray();

int posArray = 0;
while(posArray != arrayNomeFile.length){
nomeF.write(arrayNomeFile[posArray]);
posArray++;
}
nomeF.close();

posArray = 0;

while(posArray != arrayNomeFileAdapter.length){
nomeFA.write(arrayNomeFileAdapter[posArray]);
posArray++;
}
nomeFA.close();
}catch(IOException ioe){}


try{
Process p = Runtime.getRuntime().exec("javac *.java");
}catch(IOException ioe){
System.out.println("ThreadRuntime Errore durante l'esecuzione di javac *.java");
}
try{
Thread.sleep(1000);
}catch(InterruptedException ie){ie.printStackTrace();}
try{
attore = Class.forName(nameclass);
attoreAdapter = Class.forName(rAdapter);

}catch(ClassNotFoundException e){
System.out.println("ThreadRuntime:non ho trovato una o piu' classi");
}
try{
oggettoAttore = attore.newInstance();
checkpoint = true;
}catch(InstantiationException instEx){
instEx.printStackTrace();
}catch(IllegalAccessException iae){
iae.printStackTrace();
}
if(checkpoint == true){
//QUESTO QUA SOTTO E' IL PUNTO DOVE HO MAGGIORI INCERTEZZE: VA BENE?
try{
Class c = ClassLoader.getSystemClassLoader().loadClass(rAdapter);
Constructor constructor = c.getConstructor(new Class[]{attore});
Object oggettoAttoreAdapter = constructor.newInstance(new Object[]{oggettoAttore});
setObject(oggettoAttoreAdapter);
}catch(Exception g){g.printStackTrace();};
}
}
public static void main(String[] args){
ThreadRuntime t = new ThreadRuntime("Testing");
Object testO = t.getObject();
System.out.println(testO);
}

Grazie ancora a tutti x l'aiuto!!!

[-fidel-]

Per la parte che hai contrassegnato, ad occhio mi sembra di sì (non ho provato direttamente).

Io avrei però risolto in un altro modo.
Vedo che per ottenere il costruttore, crei una nuova classe di nome 'c': io sfrutterei 'attore' e 'attoreAdapter' che già crei prima.

attore = Class.forName(nameclass);
attoreAdapter = Class.forName(rAdapter);
...
Constructor constructor = attoreAdapter.getConstructor(new Class[] {attore});

Una volta ottenuto il costruttore, procedi normalmente. Sbaglio?
Tra l'altro mi pare potresti fare un po' di code cleanup

EDIT: potresti anche provare passandogli direttamente 'attore', in questo modo:

attore = Class.forName(nameclass);
attoreAdapter = Class.forName(rAdapter);
...
Constructor constructor = attoreAdapter.getConstructor(attore);

prova se funziona anche questo secondo metodo, ancora pù snello dal momento che il costruttore di 'attoreAdapter' ha un solo parametro. Non ne sono sicuro dal momento che getConstructor vuole un array come parametro.

[DesmoColo]

Pubblico la nuova versione del codice modificato, ed in fondo ad esso vi dico i problemi incontrati durante l'esecuzione:
import java.io.*;
import java.lang.reflect.*;
public class ThreadRuntime implements Runnable{

private String nameclass;
private Object oggettoRestituito;
private Boolean aspetta = false;
public ThreadRuntime(String s){

nameclass = s;
oggettoRestituito = getObject();
}
public void setObject(Object o){
oggettoRestituito = o;
}
public Object check(){
System.out.println("Metodo Check: " + oggettoRestituito);
return oggettoRestituito;
}
public Object getObject(){
Thread trt = new Thread(this,"ThreadName");
System.out.println("Faccio partire il thread");
trt.start();
try{
Thread.sleep(1000);
aspetta = true;
}catch(InterruptedException ie){
ie.printStackTrace();
}
System.out.println("Il Thread e' partito");
System.out.println("Variabile di Controllo: "+aspetta);
if(aspetta == true){
return oggettoRestituito;
}
else{
System.out.println("Il thread non ha aspettato!!! ");
}
return oggettoRestituito;
}
public void run(){
Object oggettoAttore = null;

Class attore = null;
Class attoreAdapter = null;

boolean checkpoint = false;

String rAdapter = nameclass.concat("Adapter");


String nomeFile= "public class "+nameclass + " extends Actor{public "+ nameclass+"(){};}";
String nomeFileAdapter = "import java.awt.event.*; public class " +nameclass+"Adapter extends KeyAdapter{private " +nameclass +" attore; public "+ nameclass+"Adapter("+nameclass+" a){attore = a;}}";
try{

FileWriter nomeF = new FileWriter(nameclass+".java");
FileWriter nomeFA = new FileWriter(nameclass + "Adapter.java");

char[] arrayNomeFile = nomeFile.toCharArray();
char[] arrayNomeFileAdapter = nomeFileAdapter.toCharArray();

int posArray = 0;
while(posArray != arrayNomeFile.length){
nomeF.write(arrayNomeFile[posArray]);
posArray++;
}
nomeF.close();

posArray = 0;

while(posArray != arrayNomeFileAdapter.length){
nomeFA.write(arrayNomeFileAdapter[posArray]);
posArray++;
}
nomeFA.close();
}catch(IOException ioe){}


try{
Process p = Runtime.getRuntime().exec("javac *.java");
}catch(IOException ioe){
System.out.println("ThreadRuntime Errore durante l'esecuzione di javac *.java");
}
try{
Thread.sleep(1000);
}catch(InterruptedException ie){ie.printStackTrace();}
System.out.println("dopo la sleep");
try{
attore = Class.forName(nameclass);
attoreAdapter = Class.forName(rAdapter);

}catch(ClassNotFoundException e){
System.out.println("ThreadRuntime:non ho trovato una o piu' classi");
}
try{
oggettoAttore = attore.newInstance();
checkpoint = true;
}catch(InstantiationException instEx){
instEx.printStackTrace();
}catch(IllegalAccessException iae){
iae.printStackTrace();
}
if(checkpoint == true){
try{
//Constructor constructor = attoreAdapter.getConstructor(new Class[] {attore});
Constructor constructor = attoreAdapter.getConstructor(attore);
Object oggettoAttoreAdapter = constructor.newInstance(new Object[]{oggettoAttore});
setObject(oggettoAttoreAdapter);
System.out.println("Oggetto restituito dal run:" + oggettoAttoreAdapter);
System.out.println("Dentro l'oggetto ADAPTER:" + oggettoAttore);
}catch(Exception g){g.printStackTrace();};
}
}
public static void main(String[] args){
ThreadRuntime t = new ThreadRuntime("Testing");
Object o = t.check();
System.out.println("Il main ha restituito il seguente oggetto: "+o);
}

}


Ecco i problemi:
Una volta su 200 il codice ha successo e l'output si puo vedere nell'immagine "sucesso". Le altre 199 però accade quanto riportato in immagine "errore"
La questione è questa:
Come mai il più delle volte l'oggetto rimane null? è sicuramente un problema di sincronizzazione durante l'esecuzione, ma non riesco a capire come risolverlo (è da stamattina che sono qui e sto sclerando nel tentativo di risoverlo!!!)
Che cosa sono quei residui di codice in fondo agli oggetti (per capire meglio perchè non viene restituito sempelicemente a video TestingAdapter e Testing invece di TestingAdapter@19821f e Testing@addbf1?)
Come posso elieminre tale "pattume", che anche se non so che cosa è sono sicuro che mi puo dare delle grane....

[-fidel-]

Il "pattume" di cui parli è probabilmente dato dal "name mangling" che i compilatori come C++ e Java effettuano sul nome delle variabili, dal momento che questi linguaggi, a differenza del C, permettono l'overload delle funzioni e delle classi. In C++ si usa la speciale keyword "C" per comunicare al compilatore di NON effettuare il name mangling su una funzione/classe, in Java a dire il vero non so (il name mangling causa problemi sulle dll, e con java non ho mai programmato dll ) quindi devi vedere sulla documentazione della sdk java come evitare questo. Ci sarà qualche keyword anche lì penso, ma non so dirti quale.

Per quanto riguarda la sincronizzazione: sì, hai grossi problemi di sincronizzazione, volevo dirtelo anche sul precedente esempio, ma su questa versione, se pur hai migliorato la reflection, mi pare hai incasinato di più la sincronizzzione

Lascio a te la scrittura del codice (tra poco devo andare al lavoro ) ma la linea guida può essere questa:

1) Crei il thread nel main.
2) Evita che il thread si "auto lanci" nel costruttore
3) Lancia il thread dal main (per esempio chimando il metodo getObject() come facevi prima)
4) Nel thread vedo che rischi: attendi un tempo prefissato affinchè il processo che crei per compilare le due classi attore e attoreAdapter finisca di compilare: ti conviene che il thread, dopo aver creato il processo, attenda la sua "morte".
5) Il main DEVE attendere fino a quando il thread non "muore": morendo, ritorna il valore che tu vuoi, ma il main deve aspettare: fallisce 199 volte su 200 proprio perchè, non attendendo nel main, il successo è un caso... A tal proposito toglierei la Thread.sleep() metterei nel thread l'attesa per la morte del processo che compila, nel main l'attesa per la morte del thread. Alla fine l'attesa complessiva del programma sarà "tempo di esecuzione processo compilatore + tempo di elaborazione del thread + tempo del main (trascurabile)"

[DesmoColo]

Ho modificato il codice e ne riporto l'ultima versione. Ti dico subito le modifiche fatte e gli errori (sigh!!!) che continua a dare:
- ho messo un wait nel run(), in modo che il thread aspetti la fine del processo che compila; per fare questo il thread controlla una guardia, che diventa false quando il processo ha teminato l'esecuzione;
- Ho messo un'altra wait nel main, in modo che aspetti la morte del thread per continuare l'esecuzione

In questo modo tutto sembra funzionare: l'oggetto restituito adesso è giusto.Il problema xrò è nel main: nonostante tutto termini viene sollevata la seguente eccezione:
Dentro il main si e' sollevata un'eccezione:
java.lang.Object.IllegalMonitorStateException:current thread not ower

Essendoci un while, l'eccezione viene sollevata continuamente finchè il thread non muore.
Se metto un if al posto del while non cambia niente....anche se una volta sola, l'eccezione viene ancora lanciata.
Se invece tolgo la wait() si ha come effetto che l'oggetto ritornato è ancora null, come prima.

import java.io.*;
import java.lang.reflect.*;
public class ThreadRuntime implements Runnable{

private String nameclass;
private Object oggettoRestituito;

public ThreadRuntime(String s){
nameclass = s;
oggettoRestituito = null;
}
public void setObject(Object o){
oggettoRestituito = o;
}
public Object check(){
System.out.println("Metodo Check: " + oggettoRestituito);
return oggettoRestituito;
}
public Object getObject(){
return oggettoRestituito;
}
public void run(){
Object oggettoAttore = null;

Class attore = null;
Class attoreAdapter = null;
boolean aspetta = true;
System.out.println("Aspetta e' inizializzato a true");
boolean checkpoint = false;

String rAdapter = nameclass.concat("Adapter");

String nomeFile= "public class "+nameclass + " extends Actor{public "+ nameclass+"(){};}";
String nomeFileAdapter = "import java.awt.event.*; public class " +nameclass+"Adapter extends KeyAdapter{private " +nameclass +" attore; public "+ nameclass+"Adapter("+nameclass+" a){attore = a;}}";
try{
FileWriter nomeF = new FileWriter(nameclass+".java");
FileWriter nomeFA = new FileWriter(nameclass + "Adapter.java");

char[] arrayNomeFile = nomeFile.toCharArray();
char[] arrayNomeFileAdapter = nomeFileAdapter.toCharArray();

int posArray = 0;
while(posArray != arrayNomeFile.length){
nomeF.write(arrayNomeFile[posArray]);
posArray++;
}
nomeF.close();

posArray = 0;

while(posArray != arrayNomeFileAdapter.length){
nomeFA.write(arrayNomeFileAdapter[posArray]);
posArray++;
}
nomeFA.close();
}catch(IOException ioe){
ioe.printStackTrace();
}

try{
Process p = Runtime.getRuntime().exec("javac *.java");
aspetta = false;
}catch(IOException ioe){
System.out.println("ThreadRuntime Errore durante l'esecuzione di javac *.java");
}
if(aspetta == true){
System.out.println("aspetta e' uguale a "+aspetta);
try{
wait();
}catch(InterruptedException ie){
System.out.println("Dentro il run() si e' sollevata un eccezione");
ie.printStackTrace();
}
}
System.out.println("Aspetta adesso e' "+aspetta);
try{
attore = Class.forName(nameclass);
attoreAdapter = Class.forName(rAdapter);
}catch(ClassNotFoundException e){
System.out.println("ThreadRuntime:non ho trovato una o piu' classi");
}
try{
oggettoAttore = attore.newInstance();
checkpoint = true;
}catch(InstantiationException instEx){
instEx.printStackTrace();
}catch(IllegalAccessException iae){
iae.printStackTrace();
}
if(checkpoint == true){
try{
//Constructor constructor = attoreAdapter.getConstructor(new Class[] {attore});
Constructor constructor = attoreAdapter.getConstructor(attore);
System.out.println(constructor);
Object oggettoAttoreAdapter = constructor.newInstance(oggettoAttore);
setObject(oggettoAttoreAdapter);
check();
System.out.println("Oggetto restituito dal run:" + oggettoAttoreAdapter);
System.out.println("Dentro l'oggetto ADAPTER:" + oggettoAttore);
}catch(Exception g){g.printStackTrace();};
}

}
public static void main(String[] args){
Object o = null;
ThreadRuntime t = new ThreadRuntime("Testing");
Thread thread = new Thread(t);
thread.start();
while(thread.isAlive()){
try{
t.wait();
}catch(Exception ie){
System.out.println("Dentro il main si e' sollevata un'eccezione");
ie.printStackTrace();
}
}
o = t.getObject();
System.out.println("Il main ha restituito il seguente oggetto: "+o);
}

}

[DesmoColo]

Ho risolto: è bastato cambiare la wait() con una join() e tutto sembra andar bene...

[-fidel-]

Originariamente inviato da DesmoColo

Ho risolto: è bastato cambiare la wait() con una join() e tutto sembra andar bene...

Bene, mi fa molto piacere!

[DesmoColo]

Innanzitutto ringrazio x l'aiuto avuto fino ad ora. Pubblico due post. In questo post metto il sorgente corretto e funzionante(per poterlo confrontare meglio...), mentre nel secondo pubblico il codice modificato perchè svolga il compito per il quale lo sto progettando (e per il quale sto impazzendo!!!Ma fa parte del lavoro della mia tesi di laurea e mi tocca...)
Voglio la seguente cosa:
ho una LinkedList mylista con all'interno vari oggetti di diverso tipo e di cui non conosco a priori il tipo.

voglio che il thread, una volta creata le classi attore e attoreAdapter, inizializzi un oggetto nel siffatto modo;

attoreAdapter adp = new attoreadapter((attore)mylista.getFirst());


Credo di essere sulla buona strada (solo perchè sono un tipo ottimista...magari sto sbagliando tutto! )e credo che il lavoro che il codice scritto finora debba solo essere implementato con qualche accorgimento.

import java.io.*;
import java.lang.reflect.*;
public class ThreadRuntime implements Runnable{

private String nameclass;
private Object oggettoRestituito;

public ThreadRuntime(String s){
nameclass = s;
oggettoRestituito = null;
}
public void setObject(Object o){
oggettoRestituito = o;
}
public Object check(){
System.out.println("Metodo Check: " + oggettoRestituito);
return oggettoRestituito;
}
public Object getObject(){
Thread t = new Thread(this, "ThreadRuntime");
t.start();
try{
t.join();
}catch(InterruptedException ie){
System.out.println("Errore nella join()");
}
return oggettoRestituito;
}
public void run(){
Object oggettoAttore = null;

Class attore = null;
Class attoreAdapter = null;
System.out.println("Aspetta e' inizializzato a true");
boolean checkpoint = false;

String rAdapter = nameclass.concat("Adapter");

String nomeFile= "public class "+nameclass + " extends Actor{public "+ nameclass+"(){};}";
String nomeFileAdapter = "import java.awt.event.*; public class " +nameclass+"Adapter extends KeyAdapter{private " +nameclass +" attore; public "+ nameclass+"Adapter("+nameclass+" a){attore = a;}}";
try{
FileWriter nomeF = new FileWriter(nameclass+".java");
FileWriter nomeFA = new FileWriter(nameclass + "Adapter.java");

char[] arrayNomeFile = nomeFile.toCharArray();
char[] arrayNomeFileAdapter = nomeFileAdapter.toCharArray();

int posArray = 0;
while(posArray != arrayNomeFile.length){
nomeF.write(arrayNomeFile[posArray]);
posArray++;
}
nomeF.close();

posArray = 0;

while(posArray != arrayNomeFileAdapter.length){
nomeFA.write(arrayNomeFileAdapter[posArray]);
posArray++;
}
nomeFA.close();
}catch(IOException ioe){
ioe.printStackTrace();
}

try{
Process p = Runtime.getRuntime().exec("javac *.java");
p.waitFor();
}catch(IOException ioe){
System.out.println("ThreadRuntime:errore durante l'esecuzione di javac *.java");
}
catch(InterruptedException ie){
System.out.println("ThreadRuntime:errore nell'attesa che il processo javac terminasse");
ie.printStackTrace();
}
try{
attore = Class.forName(nameclass);
attoreAdapter = Class.forName(rAdapter);
}catch(ClassNotFoundException e){
System.out.println("ThreadRuntime:non ho trovato una o piu' classi");
}
try{
oggettoAttore = attore.newInstance();
checkpoint = true;
}catch(InstantiationException instEx){
instEx.printStackTrace();
}catch(IllegalAccessException iae){
iae.printStackTrace();
}
if(checkpoint == true){
try{
Constructor constructor = attoreAdapter.getConstructor(attore);
System.out.println(constructor);
Object oggettoAttoreAdapter = constructor.newInstance(oggettoAttore);
setObject(oggettoAttoreAdapter);
check();
System.out.println("Oggetto restituito dal run:" + oggettoAttoreAdapter);
System.out.println("Dentro l'oggetto ADAPTER:" + oggettoAttore);
}catch(Exception g){g.printStackTrace();};
}
}
public static void main(String[] args){
Object o = null;
ThreadRuntime t = new ThreadRuntime("Eddie");
o = t.getObject();
System.out.println("Il main ha restituito il seguente oggetto: "+o);
}

}

[DesmoColo]

Mi scuso fin da ora se il codice del condo post è un po sporco, ma sono talmente cotto che se mi metto a pulirlo di sicuro lo incasino ancora di piu...in pratica ho provato a forzare il casting dell'oggetto dentro la lista (ipotizzando che ve ne sia uno soltanto x il momento) a attore facendo qualcosa tipo
oggettoCastato = attore.cast(primoElementoLista);

Viene sollevata l'eccezione ClassCastException....

import java.io.*;
import java.lang.reflect.*;
import java.util.*;
public class ThreadRuntime implements Runnable{

private String nameclass;
private Object oggettoRestituito;
private Class attore = null;
private Class attoreAdapter = null;
private Object oggettoDaCastare;

public ThreadRuntime(String s){
nameclass = s;
oggettoRestituito = null;
}
public void setObject(Object o){
oggettoRestituito = o;
}
public Object check(){
System.out.println("Metodo Check: " + oggettoRestituito);
return oggettoRestituito;
}
public void setOggettoDaCastare(Object o){
oggettoDaCastare = o;
}
public Object castOggetto(){
Object toCast = null;
System.out.println("Sto provando a fare il cast...");
try{
toCast = attore.cast(oggettoDaCastare);
}catch(ClassCastException cce){
System.out.println("Casting fallito!");
cce.printStackTrace();
}
return toCast;
}
public Object getObject(){
Thread t = new Thread(this, "ThreadRuntime");
t.start();
try{
t.join();
}catch(InterruptedException ie){
System.out.println("Errore nella join()");
}
return oggettoRestituito;
}
public void run(){
String rAdapter = nameclass.concat("Adapter");

String nomeFile= "public class "+nameclass + " extends Actor{public "+ nameclass+"(){};}";
String nomeFileAdapter = "import java.awt.event.*; public class " +nameclass+"Adapter extends KeyAdapter{private " +nameclass +" attore; public "+ nameclass+"Adapter("+nameclass+" a){attore = a;}}";
try{
FileWriter nomeF = new FileWriter(nameclass+".java");
FileWriter nomeFA = new FileWriter(nameclass + "Adapter.java");

char[] arrayNomeFile = nomeFile.toCharArray();
char[] arrayNomeFileAdapter = nomeFileAdapter.toCharArray();

int posArray = 0;
while(posArray != arrayNomeFile.length){
nomeF.write(arrayNomeFile[posArray]);
posArray++;
}
nomeF.close();

posArray = 0;

while(posArray != arrayNomeFileAdapter.length){
nomeFA.write(arrayNomeFileAdapter[posArray]);
posArray++;
}
nomeFA.close();
}catch(IOException ioe){
ioe.printStackTrace();
}

try{
Process p = Runtime.getRuntime().exec("javac *.java");
p.waitFor();
}catch(IOException ioe){
System.out.println("ThreadRuntime:errore durante l'esecuzione di javac *.java");
}
catch(InterruptedException ie){
System.out.println("ThreadRuntime:errore nell'attesa che il processo javac terminasse");
ie.printStackTrace();
}
try{
attore = Class.forName(nameclass);
attoreAdapter = Class.forName(rAdapter);
}catch(ClassNotFoundException e){
System.out.println("ThreadRuntime:non ho trovato una o piu' classi");
}
try{
Constructor constructor = attoreAdapter.getConstructor(attore);
System.out.println(constructor);
Object oggettoAttoreAdapter = constructor.newInstance(castOggetto());
setObject(oggettoAttoreAdapter);
check();
System.out.println("Oggetto restituito dal run:" + oggettoAttoreAdapter);
System.out.println("Dentro l'oggetto ADAPTER:" + castOggetto());
}catch(Exception g){
System.out.println("Sono qui!!!");
g.printStackTrace();}
}
public static void main(String[] args){
Object o;
TesterClass tc = new TesterClass();
LinkedList lista = new LinkedList();
ThreadRuntime t = new ThreadRuntime("Eddie");
System.out.println("Nel main dopo lo start()");
lista.add(tc);
System.out.println("Nel main dopo l'ggetto c");
t.setOggettoDaCastare(lista.getFirst());
System.out.println("Nel main dopo l'ggetto setOggettoDacastare()");
o = t.getObject();
System.out.println("Il main ha restituito il seguente oggetto: "+o);
}

}

[DesmoColo]

Ho una terza (e finalmente credo che sia l'ultima se tutto fila liscio!) questione spinosa. Spero di non farne troppe tutte insieme Dal codice dei precedenti post si puo vedere che la classe attoreAdapter estende KeyAdapter.
Lo scopo che mi sono prefissato è questo:
mi creo due classi: attore e attoreAdapter e le compilo (fin qui ci siamo);
voglio che attore sia inizializzato con dei paremetri che gli passo da esterno;
attoreAdapter è inizializzato con l'oggetto di attore inizializzato prima;

infine, visto che attoreAdapter extends keyListener, fare

addKeyListener(attoreAdapter);

Se lo faccio adesso, attoreAdapter non è riconosciuto come estensione di KeyAdapter ma come un oggetto generico che non estende niente, quindi a meno che non faccia un ulteriore casting non lo posso passare come parametro a addKeyListener. Esiste una soluzione a questo problema? in poche parole, come faccio a dire a addKeyLiestner che il parametro che gli passo va già bene così?

[^TiGeRShArK^]

ehm...
ma non puoi usare il tag code quando posti il codice?
non ho nemmeno provato a leggerlo in quel modo senza indentazioni...
nn ci capisco niente..

[DesmoColo]

Scusa...hai ragione! Ho fatto cut and paste ed è venuto fuori cosi!
facciamo così: allego un file txt con il codice pulito.
Per vederl con il testo colorato poi ti basta rinominarlo come .java