Newsgroup: it.comp.java
Titolo: Ancora sui parametri di output

Salve a tutti,
Leggendo vari messaggi su questo ng ho appreso che in java tutti i
paratri sono passati per valore.
A questo punto, se devo scrivere una procedura il cui risultato deve
essere l'impostazione di due valore di tipo int, mi chiedo  come posso
fare senza costruirmi una classe con due elementi di tipo int.
Fare questa operazione mi sembra eccessivamente oneroso per questo
tipo di problema.
Forse non ho ancora imparato a pensare in java?

 Forse non ho ancora imparato a pensare in java?
E' piu' object-orientation che java.
-- 
Life's something u don't get out alive..
ObjectZone - 
http://space.tin.it/computer/csadun

 Forse non ho ancora imparato a pensare in java?
Se vuoi portare i tuoi algoritmi da C a Java allora usa le classi wrapper, 
altrimenti considera l'ipotesi di mettere i valori in una classe. Vorrei 
anche far notare che non sei costretto a costruire le tue classi, ma puoi 
usare classi già pronte che salvino temporaneamente i tuoi dati, e dalle 
quali tu li estrai ai momenti opportuni.
Spero di esserti satto utile.
Ciao
-- 
Luca Ferrari,
fluc...@libero.it

 puntatore).
...sigh!...che disperazione.
Per favore leggiti qualche post vecchio e le FAQ.
Come si e' detto piu' volte, i parametri vengono sempre passati per
valore.
-- 
Lucio Benfante
Brainbench MVP for Java 1
http://www.brainbench.com
MyTranscript: 
http://www.brainbench.com/transcript.jsp?pid=167064

 
Le classi wrapper? Occhio che le classi wrapper sono immutable,
esattamente come la classe String, quindi non possono essere usate come
contenitori di valori che cambiano.


 valore.
Il risultato che si ottiene passando un oggetto comunque quello è e alla fine
mip are che sia il risultato quello che conta. Mi paiono questioni di lana
caprina... tipiche seghe mentali informatico/matematiche. Potete darmi
liberamente del caprone ignorante.
Ciao,
 Stefano
----------
"X WindowSSS, teSSSoro mio... lo odieremo per SSSempre"
Bill Gollum
----------

 oggetti sono passati per riferimento (nota: riferimento != puntatore).
Ugo (Landini), dove sei, non starai festeggiando l'ultimo?
:-)
tityrus

 darmi liberamente del caprone ignorante.
Il problema e' proprio che il risultato non e' quello: non si passano
oggetti. Quindi non e' vero che gli oggetto vengono passati per
riferimento: cio' che si passa e' proprio il riferimento. In java (a
parte i tipi primitivi) si lavora sempre e solo con i riferimenti. A che
scopo inventarsi che invece si lavora direttamente con gli oggetti, per
poi sistemare le cose inventando (ancora) che quando li si passa come
parametri di un metodo, cio' che viene passato e' un riferimento ad essi.
Non mi sembra una sega mentale (e mi guardo bene dal darti del caprone
ignorante), semplicemente e' dire le cose come sono (e viste in questo
modo sono semplici, facili e coerenti...senza dover poi fare i salti
mortali per far tornare i conti).
Inoltre...prima o poi sono cose che qualcuno ti chiede, o ad un esame di
certificazione o ad un colloquio di lavoro serio (a me e' successo...che
vergogna :-)...il caprone ero io :-).


 vergogna :-)...il caprone ero io :-).
Tutti i docenti Sun devono passare sotto le forche caudine del passaggio 
per riferimento/valore!
uL

 tityrus
ma che... sto studiando, come al solito. Piu' studio, piu' vedo che c'e' 
da studiare, e i giorni non bastano mai. Voglio diventare un manager, 
per riposarmi :)
a riguardo del passaggio di parametri: che Gosling sia con loro
uL



...gia', quella volta c'ero caduto...per fortuna il vostro test era
ancora in beta e Sabrina me l'aveva lasciato passare :-)


 liberamente del caprone ignorante.
Se lo dici tu, che ti conosci da tanto tempo... ;-)
Ciao

 passato "per riferimento", e non per valore...
[cut]
Beh...questo e' un altra faccenda...e dipende dal fatto che gli oggetti
String sono immutabili.


 "per riferimento", e non per valore...
Potresti cambiarlo, avendo una copia del riferimento e non l'oggetto 
originale. Nel caso specifico della classe String, pero', gli oggetti 
non possono essere modificati (come tutte le classi Wrapper dei tipi 
base) ed ogni tentativo in tal senso produrra' un nuovo oggetto e non 
una modifica di quello vecchio.
Con StringBuffer pero', potresti.
Questo e' tutto quello che c'e' da sapere per padroneggiare oggetti e 
puntatori, passaggi ecc, in Java. E' cosi' che funziona, cosi' che viene 
spiegato nelle specifiche di Java ed e' come *deve* essere insegnato per 
far capire al meglio tutte le sottigliezze.
Libri di scarso valore didattico, docenti non "ottimali" (compreso 
qualcuno all'universita' purtroppo) possono pero' continuare a 
raccontare la favoletta del passaggio per copia/riferimento.
Tanto per raccontarne una in piu', i docenti esterni che tengono corsi 
per Sun vengono rimandati a casa a studiare fino a che non raccontino 
correttamente tutta questa storia (e molte altre, chiaramente :))
uL

 
Scusa se chiedo spiegazioni su un argomento banale.
Premetto che io so che in java i parametri sono passati per valore,
su questo non ci piove, non ho ben capito il tuo commento al mio codice.
Quello che volevo far notare e' che, poiche' il metodo cambio (String)
riceve una copia del "puntatore" ad un' oggetto stringa, se io 
faccio puntare questa copia ad un nuovo oggetto String tale modifica
giustamente non si rispecchia nel "puntatore" originale.
Non ho cambiato il valore di un oggetto String, che come tu mi hai
ricordato (l'avevo scordato !!!) e' immutabile, ma cambiato il valore del
"puntatore". (Oddio, che casino, spero di riuscire a spiegarmi).
Ovvero se io ho:
String s = new String("ciao");
s = new String ("pippo");
Con la seconda istruzione non cambio il valore di un oggetto stringa
(immutabile) ma creo un secondo oggetto e cambio il valore del
"puntatore" s (che puo' mutare).
Per provare la validita' del mio ragionamento ho sostituito nel mio
breve listato il tipo StringBuffer al tipo String, ed il risultato
e' rimasto invariato:
ovvero la modifica fatta ne metodo cambio(StringBuffer) e' applicata
ad una copia dell' oggetto StringBuffer del main, che quindi non
rispecchia tale modifica.
Ovvero:
...
public void cambio (StringBuffer s)
{
 s = new StringBuffer ("pippo");
}
... main ...
StringBuffer stringa = new ("ciao");
campio (stringa);
System.out.println (stringa);
Il programma mi stampa "ciao", come mi aspetto,e dimostra che i parametri
ai metodi vengono passati per copia.
La domanda e' proprio questa: per il ragionamento sopra riportato e con il
cambiamento dal tipo String a StringBuffer, posso dire che il mio 
programmino dimostra che i parametri sono passati per copia ?
P.S. Ho usato il termine "puntatore" per cercare di essere piu' chiaro,
non credo di esserci riuscito :(, per cui se non segui il filo del
discorso no-problem... buon anno  e non pensiamoci piu'...
Ciao

 
Non ho ben chiaro perche'...
Se hai 5 minuti liberi potresti leggere la risposta che ho dato ad Ugo
Landini ?
Ciao

 discorso no-problem... buon anno  e non pensiamoci piu'...
Io credo che se usi il termine corretto (riferimento), in un newsgroup su
Java non crei ambiguita' :-)


 Se lo dici tu, che ti conosci da tanto tempo... ;-)
Per certe cose vi autorizzo anche a darmi del fesso, ma per rendervi le cose più
difficili non vi dico quali... bèèèèèèh! :)


 oggetti.
Scusa, effettivamente qui per la fretta ho scritto male io - si passa una
copia del riferimento all'oggetto.


 a riguardo del passaggio di parametri: che Gosling sia con loro
Il Throughput e' potente, in te :)


 liberamente del caprone ignorante.
Niente caprone :), ma il fatto e' che e' chiarissimo (e semplice) per chi 
ha capito, ma  non per chi sta imparando.
Come quattro quinti della matematica, del resto.


 ha capito, ma  non per chi sta imparando.
Touché :)
