Newsgroup: it.comp.java
Titolo: Passaggio per riferimento in Java

E' Possibbile passare per riferimento 2 valori a una funzione/metodo
es:
class ecc ecc
.
.
.
public void pippo(int x,int y){} //Voglio che x e y siano passati per
                                 //riferimento e non per valore in modo che
                                 //possa vedere ogni modifica fatta a quei valori.
.
.
.
}
Il fatto e che mi serve che questa funzione mi ritorni 2 valori e non 1 e 
l'unico modo che ho trovato è un passaggio per riferimento...
Ho provato a risolvere passandogli un array di 2 interi ma mi sembra molto 
rozzo come sistema...
Qualcuno mi può aiutare...
-- 
/*
Nicolò risitano
Sito web: 
digilander.libero.it/risitano
*/

 Qualcuno mi può aiutare...
Ma, veramente la funzione, anzi il metodo che hai indicato tu non ritorna
niente: è void.
Se vuoi che ti ritorni due valori, o ti fai ritornare un array, Vector, o
quel che sia, oppure ti fai restituire una  classe da te scritta che avrà
due metodi che ritornano i valori (che so, getValore() e getValore2() ).
quindi sarà una cosa tipo:
 public MiaClasse pippo(int x, int y){
   MiaClasse valori = new MiaClasse(x, y);
   return valori;
}
Comunque non ho capito bene il nesso tra la prima parte (passaggio di
parametri) e la seconda (cosa far restituire dal metodo), quindi abbiate
pazienza se ho cannato la risposta :)

 E' Possibbile passare per riferimento 2 valori a una funzione/metodo
No.
-- 
Life's something u don't get out alive..
ObjectZone - 
http://space.tin.it/computer/csadun

                                  //possa vedere ogni modifica fatta a quei valori.
No, non è possibile passare per riferimento due parametri. La soluzione 
classica è costruirsi un "holder" che contenga l'intero:
public class IntHolder
{
   private int value;
   public IntHolder(int value) { this.value = value; }
   public int getValue() { return this.value; }
   public void setValue(int value) { this.value = value; }
}
e poi utilizzarla nel seguente modo:
IntHolder a = new IntHolder(2);
IntHolder b = new IntHolder(40);
pippo(a, b);
Se devi solo utilizzare due interi comunque la soluzione è equivalente 
alla tua.
Alcuni hanno proposto come soluzione a questi prolemi una sintassi 
estesa per le nuove versioni di Java, del tipo:
int a = 2;
int b = 40;
(a, b) = pippo(a, b);
Ma non so se sia stata discussa seriamente oppure sia solo stata 
proposta in modo vago.
Gaetano Bigliardi

 No.
Telegrafico, conciso, sintetico, essenziale, incisivo, stringato e...
... perfetto!
- Dario
Una (bruttissima) alternativa (da scoraggiare) e' la seguente:
class _int {
  public _int(int v) {value = v}
  public int value;
}
public void pippo(_int x,_int y){
   x.value = 10;
   y.value = 20;
}

 classica č costruirsi un "holder" che contenga l'intero:
Correggetemi se sbaglio, ma la "holder", come la chiama Gaetano, non si
potrebbe solamente bypassare utilizzando il metodo Integer?
(java.lang.Integer)
Poi volevo aggiungere qualcosa sui passaggi di parametri:
1. Java non passa mai i tipi primitivi per riferimento.
2. Java passa per riferimento solamente i tipi composti, le classi per
intenderci, i contenitori dei tipi primitivi, Vettori, Array, Classi fatte
da te!!!
Queste solo le uniche due cose che dovresti conoscere per potertela sbrigare
da solo, Nico!!!

(java.lang.Integer)
La classe Integer e' immutabile, una volta creata su un valore questo
non e' piu' modificabile.
-- 
ciao, hal

 non e' piu' modificabile.
Non capisco la tua affermazione ...intendi forse che una variabile Integer
non può + essere modificata?
Se è così, prova ad eseguire questo:
import java.lang.Integer;
public class PI {
  public static void main(String[] args) {
    Integer a = new Integer(2);
    System.out.println(a);
    a=new Integer(5);
    System.out.println(a);
  }
}
oppure spiegami quello che intendevi, magari intendiamo cose differenti!!!
Ciao!!!
    Homer!!!



Questo intendevo, rifacendomi al quesito iniziale:
import java.lang.Integer;
public class TestRef {
 
  public static void main(String[] args) {
    Integer a = new Integer(2);
    System.out.println(a);
    provaref(a);
    System.out.println(a);
  }
 
  private static void provaref(Integer numero) {
      numero = new Integer(1000);
      return;
  }
}
L'output e', coerentemente con la documentazione:
2
2
-- 
ciao, hal

>
-- 
ciao, hal

Giusto!!!
Grazie hal!!!
Homer!!!

Nicolò Risitano wrote:
Quindi per ricapitolare il tutto l'unico modo per far ritornare 2 valori ad 
una funzione è così:
private void pippo (int[] valori)
{
  ///qui la modifica del contenuto di valori[0] e valori[1] 
}
public int topolino ()
{
    int[] valori = new int[2];
    pippo (valori);
    //Qui avrei il valore di valori modificato dalla funzione
}
Dico bene?????????


da solo, Nico!!!
Delle quali una è sbagliata e una fuorviante.
Se ne è parlato decine di volte (cerca con Google) perciò per noia mi 
limito a dire: in Java, *tutti* i parametri vengono passati per valore.
Per i dettagli: google e jls.
HTH
-- 
Ciao
	Fabrizio C.

 Per i dettagli: google e jls.
Cmq, se ti da "noia", allora perchè hai risposto?
Ciao!!!
    Homer!!!

 Non penso proprio!!!
In Java esistono due tipi di variabili:
- primitivi: int, boolean, ecc.., e
- riferimenti a oggetti
In particolare se scrivo:
int[] v = new int[100];
la variabile v non contiene il vettore, ma contiene il _riferimento_ al 
vettore stesso. Per cui se definisco un metodo nel seguente modo:
public void myMethod(int[] myArray)
passo _per valore_ il riferimento a un oggetto.
Gaetano Bigliardi

 Se ne è parlato decine di volte
C'e' anche una FAQ (m'ero dimenticato :)
http://space.tin.it/computer/csadun/javafaq.html#d205


 ha scritto nel messaggio
news:b6rovn$8b1s1$1...@ID-185876.news.dfncis.de...

infatti è questo il punto, nell'insieme oggetto-riferimento all'oggetto,
questo è uno pseudo passaggio per riferimento!!!
non sarà un vero e proprio passaggio per riferimento, se consideri il
semplice riferimento, ma riguardo all'oggetto lo è!!!
capito qual'è il punto?
Sintatticamente è corretta la tua definizione, ma logicamente parlando ...
no!!!
in sostanza quando tu programmi consideri l'oggetto o il suo riferimento?
Ciao!!!
    Homer!!!

Era proprio questo che stavo dicendo io!!!
:-)
Ciao!!!
    Homer!!!

 capito qual'è il punto?
Sì, hai perfettamente ragione.
Qui ad esempio l'autore ha coniato il termine "by-reference-value" per 
specificare il modo in cui gli oggetti vengono passati:
http://page.inf.fu-berlin.de/~dahm/doorastha/
Si legge:
"[...] Yet to stand out against the more traditional term by-reference 
which is not really suitable for Java, we will speak of 
by-reference-value passing in this paper, or of by-refvalue, for short. 
Passing an object to a method by-refvalue means that the callee operates 
on the original object via the given reference and thus may alter its 
state. However, he can not modify the contents of the original reference."
Gaetano Bigliardi

 ... perfetto!
Chi frequenta il newsgroup da un po', sa bene perche'
il buon Sadun ha risposto cosi'. E mi fermi qui! ;)
Saluti
Roberto
-- 
+----------------------------------+
| Roberto Bagnoli                  |
| Sistemi Informativi e Telematici |
| Comune di Modena                 |
| 
robe...@comune.modena.it
        |
+----------------------------------+

 limito a dire: in Java, *tutti* i parametri vengono passati per valore.
E' tutto tempo perso... ;)
Ciao


 passo _per valore_ il riferimento a un oggetto.
verissimo, viene passato per valore (cioe' copiato bit-a-bit)
l'indirizzo di memoria in cui risiede myArray.
Detto tutto questo, mi domando per quale motivo dobbiamo continuare a
chiamare "passaggio per valore" questa roba.
E' lapalissiano che _non puo' esistere un altro modo per passare
parametri_ se non per valore... _un_ valore viene comunque ficcato da
qualche parte, vuoi sullo stack, vuoi nei registri. Ma se chiamiamo
"per valore" questo tipo di passaggio, allora torniamo tutti a
lavorare in assembler... anzi, no, meglio direttamente con i trasistor
dentro ai chip, anzi, siccome di fatto non facciamo altro che far
muovere gli elettroni, potremmo chiamarlo "trasferimento elettronico".
:))) Oppure qualcuno puo' darmi un esempio di un qualche linguaggio in
cui si abbia il passaggio di parametri che sia realizzato _senza_
la'ausilio di un passaggio per valore? Forse nei computer quantici, di
cui ignoro tutto tranne il nome.
Suvvia, cerchiamo di astrarre un pochetto. Va bene, fisicamente si
tratta di un "passaggio per valore di un puntatore". Ma, per Diana,
non possiamo parlare "passaggio per puntatore" o di "passaggio per
riferimento", nello stesso modo in cui parliamo di "un bicchiere
d'acqua"? E' ovvio che con l'acqua e' difficile far bicchieri, lo
sanno anche i sassi, che motivo c'e' di continuare a ribadirlo? Si
dice "bicchier d'acqua" intendendo "un bicchiere di materiale non
specificato contenente acqua" e, per quanto mi riguarda, si dice
"passaggio per puntatore" intendendo il "passaggio per valore di un
indirizzo di memoria ... bla bla bla"
In C++ io parlo di passaggio per valore quando viene eseguita sullo
stack una copia bit-a-bit del valore del parametro che sto passando,
parlo di passaggio per puntatore quando esplicitamente passo (per
valore, va bene) l'indirizzo dell'area  di memoria contenente il dato
che voglio passare, parlo di passaggio per riferimento quando uso la
stessa notazione sintattica del passaggio "per valore" ma ottengo un
passaggio "per puntatore".
In java non ho questa possibilita' di scelta, ma ottengo sempre un
passaggio "per valore" dei tipi nativi ed un passaggio "per
riferimento" di tutto il resto.
Augh! Ho detto! :)
Buone Feste a tutti quanti.

 Augh! Ho detto! :)
Hai bevuto un po' troppo... o sei logorroico di natura?
Riassunto conciso (gia' dato mille altre volte in precedenza):
   In Java il passaggio e' per valore sia per i dati primitivi
   sia per i riferimenti agli oggetti.
- Dario

    sia per i riferimenti agli oggetti.
Ovvio, perche' mi spieghi come diavolo si puo' passare un
riferimento/puntatore se non per valore?
E' come dire che i dati vengo rappresentati grazie a stringhe di
bit... bella scoperta.
Il punto e', lo ripeto, perche' chiamarlo passaggio per valore, quando
sappiamo benissimo che la semantica e' quella di un passaggio per
riferimento/puntatore?
In alternativa ti chiedo: sai tu (o chiunque altro) farmi un esempio
di un qualunque linguaggio che passi parametri in modo diverso che per
valore?
Ovvero, mi dai una definizione rigorosa di passaggio per riferimento e
mi dimostri che e' in contrasto con quanto fa java?
Ciao

 mi dimostri che e' in contrasto con quanto fa java?
Passaggio dei parametri per riferimento: passo l'indirizzo della 
_variabile_, in Pascal:
procedure swap(var a: integer; var b: integer)
begin
   var temp: integer;
   temp := a; a := b; b := temp;
end
Pssaggio di un puntatore per riferimento:
type intpointer = integer ^;
procedure swappointers(var a: intpointer; var b: intpointer)
begin
   ... solito codice
end
var intpointer a;
inpointer b;
new a;
new b;
^a = 1;
^b = 2;
swappointers(a, b)
(la sintassi degli esempi può essere sbagliata)
Java permette solo il passaggio per valore. Dato che però gli oggetti 
non sono contenuti nelle variabili ma nello heap, io non posso passare 
il _corpo_ di un oggetto, bensì solo il suo riferimento. Se avessi il 
passaggo per riferimento potrei fare una cosa del tipo:
public static void swap(byref Integer a, byref Integer b)
{
   ... qui eseguo lo swap, modificando i riferimenti
}
In Java invece non passo indirizzi delle variabili, ma solo riferimenti 
a oggetti (come già detto prima in Java gli oggetti non sono contenuti 
in varibili ma nello heap).
Spero di essere stato chiaro.
Gaetano Bigliardi

 valore?
Ti bastano i 6 diversi tipi di passaggio di parametri sommariamente
elencati in 
http://makeashorterlink.com/?V27C56E44
 ...?
Se ne vuoi conoscere/imparare altri segui un qualsiasi corso di
"Linguaggi Formali e Compilatori".
- Dario


E' molto diverso passare un "puntatore" ad oggetto ad un metodo 
x valore o per riferimento...
Consideriamo un frammento in *metalinguaggio* in cui 
uso il termine improprio "puntatore" per non fare confusione tra
"riferimento ad un oggetto" e "passaggio per riferimento".
class Tipo
{
   int valore;
}
class chiamante {
   main ()
   {
     Tipo t = new Tipo ();
     t.valore = 10;
     cambia (t);
     print (t.valore);
   }
   static metodo cambia (Tipo x) {
     x = new Tipo();
     x.valore = 20;
   }
}
Se t fosse passato per riferimento, il metodo "cambia" avrebbe un 
riferimento al "puntatore" x, la cui modifica si ripercuoterebbe
nel main all' uscita del metodo.
Se, come in java, t viene passato per valore, il nuovo valore
dato al "puntatore" x, copia di t, non si ripercuote sull' originale.
In Java il passaggio avviene sempre per valore.
La semantica e' quella di un passaggio per valore.
In C il passaggio di parametri a funzioni avviene SEMPRE x valore,
non fare questa giusta distinsione porta a non capire il motivo per
cui per modificare un puntatore dentro una funzione bisogna passare
un puntatore a puntatore.
Ripeto:
In Java (e in C) i parametri vengono passati per valore.
La semantica e' quella di un passaggio per valore.
Distorcere questo elementare concetto porta ad una serie di errori
logici da cui poi e' spesso difficile disabituarsi.
Ciao.