Newsgroup: it.comp.java
Titolo: Variabili tra metodi senza passaggio di parametri.

Gentili iscritti,
Vi e' un modo data una classe per sapere il valore di una variabile
all'interno di un'altra classe senza usare il passaggio di parametri?
In pratica in una classe secondaria avrei l'istruzione:
JFileChooser fileChooser = new JFileChooser(directoryCorrente); 
che usa directoryCorrente, variabile inizializzata nella classe
principale del programma. Vi e' un modo per mantenere un collegamento
ovvero per sapere da dentro questa seconda classe che valore ha in
quell'istante directoryCorrente nella prima classe senza usare il
passaggio di parametri?
Grazie, un saluto.
--
Paolo Guagliumi - ICQ 46580228
[ newsletter gratuita infosapere ] - 
http://web.tiscali.it/infosapere


Forse non ho capito bene la domanda.
Perchè non vuoi il passaggio di parametri??
Che fastidio ti da scusa?

Che fastidio ti da scusa?
Ho risolto infatti con il passaggio di parametri ma il giro e' stato
"lungo e tortuoso" (!!). Perchè mi chiedevo se per caso avendo:
1) Una classe scaturita da un file "main.java" con una variabile Var
pubblica al suo interno.
2) Un'altra classe derivata da "secondo.java".
Mi chiedevo quali erano i modi per accedere alla variabile Var,
contenuta e aggiornata in "main.java" da "secondo.java". Ovvero mi
chiedevo, se per esempio sto scrivendo codice in "secondo.java", se
esistesse qualcosa del tipo 
valore = main:var;
cioe' so che non esiste, so che non e' corretto, ma Java usa a volte
delle abbreviazioni particolari, come ad esempio per l'if.. then..
else il punto interrogativo e l'uguale...
L'unico modo che mi e' venuto in mente per passarsi i valori e'
tramite parametri. 
Oppure definendo in main.java un qualcosa del tipo:
public getvaloreVar()
{
	return Var;
}
MA COME potrei chiamare o usare questo metodo da secondo.java? Ho
fatto delle prove e mi funziona il contrario, cioe' se ho
getvaloreVar(), metodo definito nell'oggetto "secondo" creato dalla
classe secondo.class allora lo richiamo facilmente da main.java. Il
viceversa non mi funziona...
Cioe' ora ho provato a fare qualche riga di codice e in main.java ho
inserito:
public String getvaloreVar()
{
	//System.out.println("prova in main" + fileXmlTagCorrente);
	return fileXmlTagCorrente;
}
e main mi crea un oggetto di nome jrfc. Se in secondo.java inserisco
la riga di codice:
System.out.println("prova in secondo.java" + jrfc.getvaloreVar());
che dovrebbe andare a prendere il valore dal metodo main... in fase di
compilazione mi da' errore...
XmlTag.java:57: cannot resolve symbol
symbol  : variable jrfc
location: class XmlTag
                System.out.println("prova"+jrfc.getval2());
                                           ^
perche' logicamente jrfc non e' niente in secondo.java. E allora mi
chiedevo... se esiste un modo per avere indietro questo valore. Chiedo
scusa se mi perdo in un bicchiere d'acqua (sono le 3.00 am... l'ora me
lo concederebbe...). Ma proprio non ho idea attualmente.
Grazie, ciao.
1 error


Che fastidio ti da scusa?
In altro modo posso dire che mi chiedo come richiamare da una "classe
non main" un metodo della classe main?
Di nuovo grazie, ciao.


 all'interno di un'altra classe senza usare il passaggio di parametri?
public class Main {
  public static String nome = "pippo";
}
public class Curiosone {
  void impicciati() {
    System.out.println(Main.nome);
  }
}
...per caso ti mancano le basi?
Ciao,
 Stefano
----------
"X WindowSSS, teSSSoro mio... lo odieremo per SSSempre"
Bill Gollum
----------

}
Beh
probabilmente lui non vuole un field di tipo static.
Comunque cambia poco.
--------------------------------
Inviato via 
http://usenet.iol.it
 

chiedevo... se esiste un modo per avere indietro questo valore. 
Beh
questo è ovvio no?
Al limite dovresti creare una istanza di Main 
Main
jrfc=new Main();
all'interno del secondo e poi dargli 
jrfc.getval2();
Ma ovviamente non gli prende il valore calcolato prima.
Comunque io direi
che tu dormi poco e alle 3.00 lavorare in java non è per nulla salutare!!
:-))
************************************
public class Primo{
private String campo;
public Primo(){
setCampo("PROVA");
}
public
String getCampo(){
 return campo;
}
public void setCampo(String
testo){
 campo=testo;
}
public void esegui(){
Secondaria sc=new
Secondaria(this);
sc.esegui();
}
 public static void main(String[]
arg){
 Primo mn=new Primo();
 mn.esegui();
	}//end main
 
}//end class
public class Secondaria{
private Primo primo;
public Primo getPrimo(){
return primo;
}
public void setPrimo(Primo testo){
primo=testo;
}
public Secondaria(Primo primo){
setPrimo(primo);
}
public void
esegui(){
System.out.println(""+getPrimo().getCampo());
}
}//end
Secondaria
Ovviamente questo è solo un esempio e tutto lo devi
adattare al tuo caso specifico, comunque la logica è quella.


Comunque cambia poco.
Grazie mille a te e a Stefano per l'aiuto. Ho risolto il problema
grazie al tuo esempio "nipogabri" (forse Gabriele?). In particolare ho
usato il tuo esempio per capire dove arrivavo e la soluzione e' data
da questa riga di codice scritta nella classe principale del tuo
programma:
Secondo oggettoSecondo = new Secondo(this);
Ovvero quando creavi l'oggetto secondo gli passavi con "this" anche
"se stesso". Sara' certamente banale, ma e' sempre semplice ciň che si
sa, un po' meno cio' che ci sfugge in quel momento o che non si sa. In
particolare in tutti i miei esempi non avevo mai avuto bisogno
esplicito da una classe "secondaria" accedere a valori di una classe
primaria. Passavo diverse volte "this" e in effetti ieri pensavo
"dovrei passare se stesso, ma come?". E la soluzione era molto
semplice ma non vi arrivavo, sara' stata l'ora tarda (eh, eh!).
Arrivavo a scrivere qualcosa di *simile* a ciň che ha scritto Stefano
ma non mi funzionava e non avevo pensato a questa semplice e basilare
soluzione. Alla fine io passavo come parametro non "this" ma solo la
stringa di testo e non mi piaceva come cosa. Che dire, ignoranza mia,
eh, eh. E visto che non si finisce mai di imparare, grazie ad entrambi
e in particolare a "nipogabri" per il prezioso suggerimento nel
codice. Segue il codice rivisto che mi ha permesso di capire:
public class Primo // classe principale contenente il main
{
	private String testo; // testo 
	public Primo()
	{
		testo = "testo inzializzato in primo";
		Secondo oggettoSecondo = new Secondo(this);
	}
	public String getTesto()
	{
		return testo;
	}
	public static void main(String[] arg)
	{
 		Primo oggettoPrimo = new Primo();
	}
}
public class Secondo
{
	private Primo oggettoPrimo;
	public Secondo(Primo oggettoPrimo)
	{
		System.out.println("Output di secondo: " +
oggettoPrimo.getTesto());
	}
}
Ciao, un saluto!


}
Si, in realta' mi sono reso conto che per il funzionamento dei due
listati (Primo.java e Secondo.java) cosi' come sono la riga di
Secondo.java: 
"private Primo oggettoPrimo;"
e' inessenziale e quindi Secondo.java sarebbe:
public class Secondo
{
  public Secondo(Primo oggettoPrimo)
  {
    System.out.println("Output secondo: " + oggettoPrimo.getTesto());
  }
}
Ciao.


 Comunque cambia poco.
Ho messo static per non mettermi a costruire istanze di oggetti.
Comunque cambia poco. ;)
