Newsgroup: it.comp.java
Titolo: Sono quasi disperato

Scusate di nuovo la mia ennesima domanda ma non posso farne a meno perché
mi fa impazzire.
" le variabili di tipo classe come parametri di tipo oggetto sono passate
per riferimento, il che significa che le operazioni svolte su di esse nel
metodo hanno effetto sugli oggetti originali. Ciò vale anche per gli array
e per il loro elementi: quando si passa un array a un metodo e se ne
modifica il contenuto, si modifica di fatto l'array originale(i tipi
primitivi, invece, sono passati per valore). 
"
Questo è quanto diceva il mio vecchio libro su java 1.2 (con specifiche
sulla beta 3) edito da apogeo guida completa.
Ma non è più così vero?
Allora quando io scrivo Button a = new Button(); creo semplicemente una
variabile di tipo button con un oggetto come valore, quindi non esistono in
Java nemmeno più i riferimenti.
Se è così domando scusa per la spiegazione sugli array perché ho detto
allora un mucchio di castronate e farei meglio a cambiare linguaggio.
Saluti.

 Java nemmeno pi? i riferimenti.
Non vorrei dire fregnacce ma mi e' sembrato di vedere che il meccanismo delle
references a oggetti e' rimasto e -al massimo- e' stato migliorato con lo
strumento delle weak references.
carlo
--
"Science is like sex: sometimes something useful comes out,
                      but that is not the reason we are doing it"
                                                -- Richard Feynman
 

in Java nemmeno piů i riferimenti.
No. Continui a creare un oggetto sullo heap, e "a" continua ad essere una 
variabile il cui valore e' un riferimento a quell'oggetto.

 
scusa, cosa ti fa credere che le cose siano cambiate?
A quanto mi risulta l'accesso agli oggetti in Java avviene sempre e
solo per riferimento, e non penso proprio che si tornera` mai indietro!
-- 
Ciao, Matteo                          !!   Memories flashin' through my head
                                      /\   Was I just born or am I dead?
mailto:
matteo.mattia
 (at) 
libero.it
   \/                -- The Morning After
                                      ¡¡                     Faith No More

Provate allora questo codice:
class PassaPerRiferimento {
        int metodo(int arr[]) {
               int a = 0;
               for(int i = 0; i < arr.length; ++i) {
                   if(arr[i] == 0) {
                     arr[i] = 1;
                     ++i;
                  }
               }  
           return a;
       }
       public static void main(String[] arguments) {
                int arr[] =  { 0, 0, 0, 1, 0, 0 };
                int a;
                PassaPerRiferimento oggetto = new PassaPerRiferimento();
                for(int i = 0; i < arr.length; i++)
System.out.println(arr[i]);
                int a = oggetto.metodo(arr);
                for(int i = 0; i < arr.length; ++i)
System.out.println(arr[i]);
                Systen.out.println("numero 0 contati" + "" +  a);
                System.exit(0);
        }
}
L'output dovrebbe essere:
      000100
      111111
      5
invece è:
      000100 
      000100
      5
.
Inoltre proviamo questo:
class Myclass {
        public static void main(String [] arguments) {
                  String a = "ciao";
                  String b = a;
                  System.out.println(a);
                  System.out.println(b);
                  b = "altra stringa";
                  System.out.println(a);
                  System.out.println(b);
                  System.exit(0);
}      
output: 
         ciao
         ciao
         ciao
         altra stringa
quando dovrebbe essere:
          ciao
          ciao
          altra stringa
          altra stringa
dato che sia a che b riferiscono allo stesso oggetto.       
Forse non mi ero spiegato nell'altro post.
Cmq grazie.
Saluti.

Guardando i risultati di alcuni codici ho tratto le mie conclusioni.
Saluti.

Scusate,  ma per errore di battitura ho scritto:
                   if(arr[i] == 0) {
                     arr[i] = 1;
                     ++i;
                  }
invece di:
              if(arr[i] == 0) {
                 arr[i] = 1;
                 ++a;
              }
Saluti.

frances...@libero.it
 (Francesco Fassi) wrote in <01c02222$552b2fe0
$LocalHost@libero>:
Non ho letto in dettaglio il tuo primo snippet (ad esempio, dichiari due volte 
"a", perche'?), ma nel secondo non "dovrebbe essere" nient'altro che quello che 
effettivamente e'.
Crei un oggetto "ciao" e fai si' che "a" punti a tale oggetto.
Crei un riferimento "b" e gli assegni lo stesso valore di "a", ovvero "b" punta 
allo stesso oggetto "ciao".
Stampi l'oggetto riferito da "a": "ciao"
Stampi l'oggetto riferito da "b": "ciao"
Crei un nuovo oggetto "altra stringa" e fai si' che "b" punti a tale oggetto.
Stampi l'oggetto riferito da "a": "ciao"
Stampi l'oggetto riferito da "b": "altra stringa"
Stai confondendo l'operatore di assegnamento (=) con la dichiarazione algebrica 
di identita' (che in Java non esiste: hai bisogno di cose come CafeOBJ per 
quello). La semantica di "b=a" non e' che da li' in poi il valore di b sara' 
sempre uguale al valore di a, ma che il valore di b viene assegnato col valore 
di a al momento dell'esecuzione dello statement. 
Quindi quando assegni "b", due righe di codice dopo, cambi appunto il valore di 
b, ma quello di a resta inalterato.


La prima a è una variabile locale del metodo, mentre la seconda è sempre
una variabile locale,  ma è all'interno di main.

Ritiro la domanda in questione, la mia è stata solo una svista dovuta a un
mio errore logico nel programma. 
Ma mi spiegate perché in una discussione un po' vecchiotta su un confronto
tra Java e C++  Ugo Landini (non corretto da nessuno) ha affermato che in
Java tutto viene passato per valore, compresi gli oggetti ?
Saluti.

 Saluti.
Per valore vengono passati anche gli oggetti in quanto passi per valore
l'indirizzo dell'oggetto.
Ciao
--------------------------------------------------------------------
*  Antonio  Talarico
*
* 
tony...@libero.it
*
* 
http://utenti.tripod.it/toniuccio/
--------------------------------------------------------------------

 Saluti.
In Java esiste *solo* il passaggio per valore: e` giusto.
Ma al tempo stesso gli oggetti sono accessibili *solo* tramite reference.
Quindi se si passa un oggetto per parametro, quello che si ottiene e`
un passaggio per valore: del reference! :)
sembra una sottigliezza, ma non e` proprio la stessa cosa che un passaggio
per variabile...
-- 
Ciao, Matteo                        !! Memories flashin' through my head
                                    /\ Was I just born or am I dead?
mailto:
matteo.mattia
 (at) 
libero.it
 \/              -- The Morning After
                                    ĄĄ                   Faith No More

Grazie della spiegazione.
Es.:
int a = 10;
int b = a; // la variabile a rilascia il valore in essa contenuto e
successivamente viene //"copiato"  in b
Button oggetto = new Button(); 
Button oggetto2 = oggetto; // caso uguale al precedente con la sola
differenza che il //valore di oggetto non viene copiato in oggetto2, ma si
crea invece un riferimento //verso tale oggetto
Quindi in Java non esiste un vero e proprio passaggio per riferimento ma
solamente, se così possiamo definirlo, uno a metà tra p. per riferimento e
p. per valore?
Saluti.

 Saluti.
-- 
Ciao, Matteo                        !! Memories flashin' through my head
                                    /\ Was I just born or am I dead?
mailto:
matteo.mattia
 (at) 
libero.it
 \/              -- The Morning After
                                    ¡¡                   Faith No More

p. per valore?
A basso livello, invocare una funzione con parametri comporta sempre la copia 
di qualcosa sullo stack frame locale.
Il passaggio per valore comporta allocare spazio per l'intero tipo di dato e 
copiare pari pari il contenuto. Una classe, ad esempio, puo' richiedere 300 
byte - il psg. per valore alloca e copia 300 byte. Questo e' quanto avviene, ad 
esempio, in C++ quando non usi puntatori * o riferimenti &.
Il passaggio per riferimento comporta allocare spazio per un puntatore al tipo 
di dato. In genere la memoria allocata e' sempre la stessa - in dipendenza 
dall'architettura di macchina. Quello che viene copiato e' il valore del 
puntatore, appunto. Si parla di "puntatore" o "riferimento" a seconda che sia 
possible o meno accedere e fare aritmetica sul valore passato. Java usa solo 
riferimenti; C++ mette a disposizione entrambi,
Il "passaggio per variabile" e' ad un livello di astrazione leggermente piu' 
alto: ti dice solo che le modifiche al parametro che esegui nel body della 
funzione sono presenti al termine della esecuzione della stessa. La cosa si 
puo' implementare sia tramite puntatori che reference (o anche senza, volendo, 
in modo inefficiente). C ad esempio non passa mai per variabile; Java invece 
passa per variabile solo i tipi non primitivi.