Newsgroup: it.comp.java
Titolo: [newbie] Gestione Stack

Perchè
class element
{
     int val;
     public element(int x)
     {
          this.val=x;
     }
}
...
    Stack s=new Stack();
    element A=new element(5);
    s.push(A);
    A.val=8;
    useit.push(A);
    A=null;
    element B=new element(0);
    B=(element) useit.pop();
    System.out.println(B.val);
    B=(element) useit.pop();
    System.out.println(B.val);
Non funziona ? Se non uso il cast (element) il mi dà errore in compilazione;
in questo modo gira ma non fa ciò che dovrebbe.
Cioè la println non mi stampa affatto l'ultimo elemento estratto dallo
stack, bensì solo l'ultimo valore di A.a (sarebbe a dire 8).
Qualcuno ha idea di come aiutarmi ?
Grazie in anticipo.

     useit.push(A);
       ^^^^


 Qualcuno ha idea di come aiutarmi ?
Quando inserisci l'elemento A nello stack non viene fatta una copia
dell'oggetto ma viene semplicemente messo nello stack il rifermento
all'oggetto.  Per questo motivo se poi modifichi l'oggetto A in realtà
modifichi anche il contenuto dello stack.
Ti consiglio di studiare bene i concetti di oggetto e riferimento ad un
oggetto che sono la base di Java.
--
Nothigman

 Cosa è useit?
useit era il nome che avevo dato precedentemente alla variabile di referenza
e mi sono dimenticato di modificare...
cmq nel codice avevo usato lo stesso nome da tutte le parti, non era quello
il problema ;)


 wrote in message
e_Re8.17747$Ns4.7...@news2.tin.it...

 Grazie della delucidazione ! I concetti di oggetto e riferimento ad un
oggetto penso di averli ben chiari, è che non avevo la minima idea che nello
stack venisse messo il riferimento e non l'oggetto vero e proprio.
Grazie ancora !

newbie anche nel postare.
per rispondere devi usare Re: altrimenti il thread salta e dopo
qualche post non ci si capisce + niente.
Grazie Microsoft(scommetto che usi outlook e.)
Ti consiglio vivamente software alternativi per i ng(io ad esempio uso
free agent)
Ciao Andrea

 stack venisse messo il riferimento e non l'oggetto vero e proprio.
Mi sa che invece i concetti suddetti non ti sono affatto chiari...
In Java puoi utilizzare gli "oggetti veri e propri" (come li chiami
tu) SOLO attraverso dei reference (che sono cosa completamente distinta
dagli oggetti!).
Se ti e' piu' semplice vederla cosi' (anche se non e' proprio la stessa
cosa)
puoi paragonare i reference a dei puntatori (alla C++, per intenderci)
"mascherati".
I reference possono essere inizializzati in due modi (escludo il terzo, 
legato alla gestione delle eccezioni, perche' per questa discussione non
e' 
determinante):
1) assegnandovi il risultato dell'invocazione di un costruttore
   di una classe (invocazione mediata dalla parola chiave new)
   Es: (preso dal tuo esempio):
   element A = new element();
2) assegnandovi il contenuto di un altro riferimento
   Es:
   element B = A;
Mentre nel primo caso al riferimento viene effettivamente assegnato
il "puntatore" ad una NUOVA area di memoria che contiene un NUOVO
oggetto, nel secondo non viene creato nulla di nuovo, ma si avranno
semplicemente due reference che permettono di utilizzare lo STESSO
oggetto.
Tornando al tuo caso, la classe Stack e' una estensione di Vector
(vedere la API DOC per credere), e come tale si limita a mantenere
una lista di reference agli oggetti che vi vengono inseriti, e non
una loro copia. 
Vediamo di analizzare nel dettagli lo spezzone di codice
che hai "postato":
class element 		// In Java, per convenzione, i nomi delle classi 
			// vengono fatti iniziare con una lettera maiuscola
{
     int val;
     public element(int x)
     {
          this.val=x;	// Il this in questo caso e' perfettamente 
			// inutile perche' non vi e' sovrapposizione di
			// nomi tra parametri formali del costruttore e
			// variabili d'istanza 
     }
}
...
1   Stack s=new Stack();
2   element A=new element(5);	// Crei un nuovo oggetto di tipo element
				// e lo "colleghi" al reference A
3   s.push(A);	// Al termine dell'esecuzione di questa istruzione, 
		// esistono DUE reference all'oggetto di tipo element 
		// creato al punto 2: uno e' A, l'altro e' interno 
		// allo stack.
 
4   A.val=8;	// Questa istruzione modifica l'attributo val 
		// dell'oggetto "collegato" al reference A, che
		// e' lo stesso "collegato" al reference 
		// precedentemente inserito nello stack.
5   s.push(A);	// Qui hai semplicemente inserito un'altra volta
		// lo stesso reference sullo stack, il quale ora
		// conterra' DUE reference allo STESSO oggetto
6   A=null;	// A cosa ti serve?	
7   element B=new element(0);	// Questa inizializzazione e'
perfettamente 
				// inutile, in quanto il nuovo oggetto diventa 
				// immediatamente "irraggiungibile" a causa
				// dello statement successivo.
8   B =(element) useit.pop();	// Si poteva semplicemente scrivere:
				// element B = (element) s.pop();
    // Con l'istruzione precedente tu hai semplicemente estratto 
    // dallo stack il reference che si trovava in cima alla pila,
    // che e' "collegato" all'oggetto creato al punto 2
9   System.out.println(B.val);	// Stampa correttamente 8, cioe'
				// l'ultimo valore assegnato a
				// tale attributo (punto 4)
10   B=(element) s.pop();	// Idem come sopra
11   System.out.println(B.val);
Nessun malfunzionamento, quindi: devi solo prendere un po'
piu' di confidenza con la semantica del linguaggio Java e con
il funzionamento delle classi della sua libreria.
Saluti
Roberto
-- 
+-------------------+
| Bagnoli Roberto   |
| Nouvelle srl      |
| MODENA (ITALY)    |
| 
rbag...@orion.it
 |
+-------------------+