Newsgroup: it.comp.java
Titolo: passaggio dei parametri in una funzione

Salve Ragazzi ho un problema sul passaggio dei parametri in un metodo.Se ho
una funzione in una classe
private void tm(Time t,Long C)
{
     // costruisco lo stato di C;
}
e in un metodo chiamo questa funzione cosi':
public void prima(......)
{
     Long L=null;
    tm(f,L);
}
Come posso fare in modo da variare lo stato dell' oggetto referenziato da L
senza Dichiarare la variabile L al di fuori del metodo?
(l'equivalente c del passaggio per riferimento delle variabili)
grazie
Samba

 (l'equivalente c del passaggio per riferimento delle variabili)
Forse non ho ben capito il problema perchè parli di funzioni (non esistono)
e metodi in maniera molto confusa. Cmq in Java il passaggio di variabili
avviene quasi sempre per riferimento (c'è un thread enorme a riguardo).
Il fatto è che tu lavori in questo caso con una variabile locale e quindi
esiste solo all'interno di quel metodo dove la definisci.
--------------------------------
Inviato via 
http://usenet.libero.it

Se non ho capito male le tue intenzioni non puoi semplicemente fare quello
che dici: in Java il passaggio avviene esclusivamente per valore (i
parametri oggetto sono effettivamente dei reference).
Non puoi neanche passare un Long già inizializzato perchè non è possibile
alterarne il valore.
Una soluzione adatta a quello che sembri voler fare è semplicemente:
 private Long tm(Time t)
 {
       Long C;
      // costruisco lo stato di C;
        return C;
 }
 public void prima(......)
 {
      Long L=  tm(f);
 }
Ciao,
    Alessio


il metodo non mi deve restituire niente nel mio caso
 tale funzione e' ricorsiva....


 (l'equivalente c del passaggio per riferimento delle variabili)
Direttamente non si puo'. Come in C, Java passa sempre per valore.
Ovviamente puoi incapsulare L come attributo di in un oggetto che esponga 
un metodo per modificarlo.
-- 
Life's something u don't get out alive..
ObjectZone - 
http://space.tin.it/computer/csadun

 avviene quasi sempre per riferimento (c'è un thread enorme a riguardo).
Orrore!
In Java il passaggio di variabili avviene *sempre* per *valore*.
-- Dario


Mah, secondo me è un discorso di lessico.
Diversi libri indicano un pass. per valore limitato ai soli dati primitivi,
mentre per gli altri è per riferimento.
E' solo da chiarire cosa si intende per riferimento.
Cmq discorso chiuso, c'è già un thread a riguardo più che esauriente.


 Mah, secondo me è un discorso di lessico.
Temo di no. "per riferimento" e "per valore" (nel contesto di passaggio 
di parametri) hanno un significato tecnico piuttosto preciso e condiviso, 
quindi non e' che uno se lo possa reinventare come piace a lui.
Se ci sono dei libri che lo fanno, sono libri errati.
Tra l'altro, val la pena aggiungere una nota: _chiunque_ puo' pubblicare un 
libro, date le opportune circostanze. Che una cosa stia in un libro (o in 
un giornale, etc) non e' affatto garanzia di correttezza. In genere, dato 
un argomento X, ogni anno si pubblicano almeno un centinaio di libri su X, 
e di *buoni* libri ce ne sono, in media, una decina ogni dieci anni. Fai un 
po' il conto. :-)



Mettila come ti pare, ma se passo ad un metodo un array come parametro e lo
modifico, l'array rimane modificato anche all'uscita del metodo.
Per me questo significa passare per riferimento.


 Per me questo significa passare per riferimento.
L'ho capito, e per questo rispondevo: c'e' gia' abbastanza confusione a 
proposito ed e' meglio evitare che altri facciano lo stesso errore. :)
Il perche' quanto dici non e' corretto ha a che fare coi dettagli di 
allocazione dei parametri nello stack frame creato all'invocazione di un 
metodo: basta leggersi la JVM spec, in particolare dove dice "The Java 
virtual machine uses local variables to pass parameters on method 
invocation." e seguenti, e la precedente definizione di local variables. 
In sostanza, i parametri vengono *copiati* nello stack frame locale - che 
e' la semantica di passaggio che si chiama "per valore". Uno dei tipi 
possibili per le local variables e - guarda un po' - "reference".  ;-)



| When the method or constructor is invoked (§15.12),
| the *values* of the actual argument expressions initialize
| newly created parameter variables, each of the declared Type,
| before execution of the body of the method or constructor.
Quindi il passaggio dei parametri in Java e' *sempre* per valore,
qualsiasi sia il tipo (tipi primitivi o reference a Object)
delle espressioni usate nella invocazione del metodo.
Se fosse possibile il passaggio per riferimento
allora sarebbe possibile scrivere un metodo f
che ricevendo una variabile v
faccia stampare la frase incriminata qui sotto.
    ... v; // dichiarazione di v (qualsiasi tipo)
    ...
    v = ...; // assegnamento di v (qualsiasi valore)
    ...
    {
      Object o1 = v;
      Object o2 = v;
      f(o1);
      if(o1 != o2)
        System.out.println("Se questa frase viene stampata "+
"allora ho torto!");
    }
    ...
In C (dove c'e' il passaggio per riferimento) la cosa e' banale.
In Java e' impossibile.
-- Dario


NOOOoo.. non ricominciamo con questa storiaa, non se ne puo' piu'! 
Se te lo chiedono tu di' che i parametri sono passati per valore anche
se segretamente li usi come si trattasse di riferimenti :)))  
 

 NOOOoo.. non ricominciamo con questa storiaa, non se ne puo' piu'! 
:-)
E' che imho queste e' una delle "piccole" confusioni da cui (tutte insieme) 
poi emerge software spazzatura. Quindi meglio cercare di appianarle appena 
si puo'.


 Per me questo significa passare per riferimento.
Prova (se hai ancora tempo e /voglia/) a leggere questo brevissimo documento:
http://www-scf.usc.edu/~csci410/misc/paramPass.pdf
-- Dario

 se segretamente li usi come si trattasse di riferimenti :)))
Cristiano Sadun, Ugo Landini ed il sottoscritto ci siamo piu' 
volte sforzati di chiarire i concetti relativi al passaggio di 
parametri in Java.
Noto che, con quante argomentazioni (corrette!) si portino e 
anche citando la specifica ufficiale, non se ne viene a capo: 
vi e' l'ostinazione a voler interpretare le cose come non sono!
In Java il passaggio dei parametri e' SEMPRE PER VALORE.
In particolare, anche i reference sono passati PER VALORE, quindi
significa che:
- il reference stesso puo' essere modificato dal metodo chiamato,
  ma tale modifica (al reference, non all'oggetto cui esso punta!) 
  NON verra' "vista" dal chiamante;
- se il chiamato, utilizzando il reference passato, invoca 
  metodo che ha l'effetto collaterale di modificare lo stato
  dell'oggetto cui il reference punta, allora anche il chiamante
  "vedra'" tale modifica allo stato.
  E' quest'ultimo punto che spesso genera confusione tra coloro 
  che cominciano e che non hanno ancora ben chiara la differenza
  tra reference ed oggetti.
Non riesco a trovare un modo piu' semplice per dirlo e giuro 
che questa e' l'ultima volta che intervengo sull'argomento! :)
Saluti
Roberto
-- 
+-------------------+
| Bagnoli Roberto   |
| Nouvelle srl      |
| MODENA (ITALY)    |
| 
rbag...@orion.it
 |
+-------------------+

 
sai che non e'cosi'... :)
ma ho un'idea. Perche' non scriviamo un paio di paginette ben fatte, 
formalmente ineccepibili e le pubblichiamo in italiano su 
www.sun.it
? 
Che ne dite?
Non so se riesco ad arrivare facilmente fino a 
java.sun.com
 o javaworld 
(ovviamente traducendo in inglese), ma su 
www.sun.it
 appena abbiamo 
qualcosa non c'e' problema.
Fra l'altro volevo istituire una rubrica Sun per newbie in Italiano, ma 
da solo non ho tempo di produrre tutto il materiale: Cristiano, Bruno, 
Luigi, ecc... avete tempo per articoli per iniziandi, diciamo 2-3 
all'anno?) Che ne dite?
Devono essere argomenti semplici ma esaustivi, su argomenti base tipo 
CLASSPATH, passaggi di parametri, String e StringBuffer, ecc. ecc.
ciao
uL

Roberto

 CLASSPATH, passaggi di parametri, String e StringBuffer, ecc. ecc.
Gia' da google in genere si riescono a recupare signore risposte su questi 
argomenti. 
Il mio problema e' che col tempo che ho, ho tre quarti di FAQ in XML (che 
mi semplificherebbe la vita enormenente nell'aggiungere 
domande/risposte/sezioni) da natale scorso con la sua bella XSLT che ti 
produce al volo l'html - e non sono ancora riuscito a completare l'ultimo 
quarto. :(
Pero' molte risposte sul ng sono assolutamente riusabili. Ma non c'e' 
peggior sordo di chi non vuol sentire.. :)
