[JAVA] un dubbio o mistero da sfatare

[misterx]

mi sono risvegliato

    public int compareTo(Object o) {
        if (this.getlato() > ((Cubo)o).getlato() )
            return 1;
        else if (this.getlato() < ((Cubo)o).getlato() )
            return -1;
        else
            return 0;
    }

[PGI]

Potenzinterra, usiamo le parentesi graffe per gli "if"!

http://java.sun.com/docs/codeconv/

[misterx]

il metodo equals non funziona e so anche il perchè ma non so perchè viene sempre natuarale scriverlo così

class Scheda{
    public static void main(String[] args){
        
    Cliente obj1 = new Cliente("Galli","Massimo","Manzoni",18);
    Cliente obj2 = new Cliente("Galli","Massimo","Manzoni",18);
    
    if (obj1.equals(obj2) )
        System.out.println("vero");
    else
        System.out.println("falso");       
    }
}

class Cliente{
    String cognome;
    String nome;
    String via;
    int numero;
    
   
    public Cliente(String c , String n , String v , int num){
        cognome = c;
        nome = n;
        via = v;
        numero = num;
    }
   
}

[PGI]

ehm...potrei sbagliarmi ma a me sembra che in Cliente di metodi "equals" non ce ne siano proprio (salvo quello ereditato da Object che per i motivi che sappiamo non funziona in questi casi).

[misterx]

e bravo

e io non riesco ada abbandonare il concetto che equals è un metodo che va implementato ogni volta e non una funzione superautomatica di java

mi ero fissato che passando ad equals due indirizzi ci pensasse lui a scandire l'intera scheda, quella della classe precedente da me postata; invece va sbriciolata ed analizzata elemento per elemento

me ne dimentico sempre

[misterx]

leggo che in java l'unico modo per scambiare dati tra metodi è per valore e non per riferimento ?

mi viene in mente il compareTo dove gli viene passato un indirizzo=riferimento

ma vi sono anche altri casi analoghi dove ad un metodo viene passato un riferimento; che significa in java tutto ciò ?

che viene alterato all'interno di un metodo una copia e non l'originale ?

[PGI]

All'interno del metodo è alterata una copia se il passaggio è per valore (capita solo con i primitivi).

Se il passaggio è per riferimento viene creata una copia del riferimento: chiamare un metodo o modificare un campo del riferimento-copia genera un mutamento corrispondente sull'oggetto in memoria, osservabile anche attraverso il riferimento originale. Riassegnare il riferimento copia, al contrario, non comporta un corrispondente riassegnamento dell'originale, poichè l'oggetto puntato originariamente rimane dov'era.

A questo punto si può giustificare quello che hai letto: affinchè due metodi possano interagire con lo stesso valore si rende necessario incapsulare il valore (di un primitivo o di un riferimento) all'interno di un oggetto, il cui puntatore sarà passato tra i metodi.

[recoil]

riassumento puoi dire che in Java i parametri sono passati sempre per valore.
se pero' consideri che l'istanza di un oggetto rappresenta il puntatore all'area di memoria allora puoi concludere che il passaggio di parametri (tranne che nel caso di tipi primitivi) ha lo stesso effetto di un passaggio per riferimento

[misterx]

Originariamente inviato da recoil
riassumento puoi dire che in Java i parametri sono passati sempre per valore.
se pero' consideri che l'istanza di un oggetto rappresenta il puntatore all'area di memoria allora puoi concludere che il passaggio di parametri (tranne che nel caso di tipi primitivi) ha lo stesso effetto di un passaggio per riferimento

azz, sono andato in confusione

- il metodo main passa un valore ad altro metodo attraverso i suoi parametri

- i parametri di un metodo il mio libro dice che sono locali, ed è vero perchè dall'esterno sono invisibili

- il metodo ricevente agendo in un'area di memoria protetta, modifica il valore pervenutogli dal main

- quando il metodo ricevente lo ritorna al metodo main, è il metodo main stesso che lo sostituisce col nuovo

se è così è, boh, mi sembra un ottimo modo per proteggersi in quanto non possono due metodi alterare allo stesso tempo il medesimo valore

cmq, non so se ho capito

[PGI]

Originariamente inviato da recoil
riassumento puoi dire che in Java i parametri sono passati sempre per valore.

Riassumendo io direi il contrario, significa che sono stato veramente molto chiaro, mi devo fare i complimenti da solo .

[misterx]

Originariamente inviato da PGI
Riassumendo io direi il contrario, significa che sono stato veramente molto chiaro, mi devo fare i complimenti da solo .

non hai risposto alle mie perplessità

[PGI]

Mah, qui si comincia a parlare di parametri, valori, riferimenti, istanze di oggetti e metodi che restituiscono cose, la creatività è magnifica ma bisognerebbe quantomeno chiarire un attimo per ogni termine cosa si intende. Dovremmo farlo ogni volta che scriviamo un post, tipo "il metodo "a" passa il riferimento (puntatore ad un'istanza di classe in memoria) al metodo "b", b riceve una copia del riferimento (puntatore alla stessa istanza di classe del riferimento passato da a), maneggia questa copia e poi restituisce il controllo al metodo chiamante (return). Se specificato restituisce anche un tipo (reference o primitivo)".

misterx, tu mi scrivi "il metodo chiamante lo ritorna al main" non era il main il chiamante? E che ritorna? Al metodo ricevente è arrivato un valore? Perchè? Troppe domande per i miei due neuroni!

[misterx]

Originariamente inviato da PGI
Mah, qui si comincia a parlare di parametri, valori, riferimenti, istanze di oggetti e metodi che restituiscono cose, la creatività è magnifica ma bisognerebbe quantomeno chiarire un attimo per ogni termine cosa si intende. Dovremmo farlo ogni volta che scriviamo un post, tipo "il metodo "a" passa il riferimento (puntatore ad un'istanza di classe in memoria) al metodo "b", b riceve una copia del riferimento (puntatore alla stessa istanza di classe del riferimento passato da a), maneggia questa copia e poi restituisce il controllo al metodo chiamante (return). Se specificato restituisce anche un tipo (reference o primitivo)".

misterx, tu mi scrivi "il metodo chiamante lo ritorna al main" non era il main il chiamante? E che ritorna? Al metodo ricevente è arrivato un valore? Perchè? Troppe domande per i miei due neuroni!

e vabbè, un piccolo errore dovuto alla........ ed alla ...... ed a....

ho corretto

[PGI]

Non è una questione di semantica, non mi permetterei mai di segnalare ironicamente un errore di battitura, proprio io che ho lo dita dotate di volontà propria (a malapena evito di ribattere le stesse cose dieci volte)

Originariamente inviato da misterx
azz, sono andato in confusione

- il metodo main passa un valore ad altro metodo attraverso i suoi parametri

Quindi il main sta chiamando un altro metodo che accetta come parametro un primitivo (boolean o numerico). Questo è il senso di quella frase, per come funziona Java, ma, scommetto un decino, non è quello che volevi dire (vero o no?)

- i parametri di un metodo il mio libro dice che sono locali, ed è vero perchè dall'esterno sono invisibili

Gosling conferma e noi, con due fonti (il tuo libro più il mio), ci fidiamo. E' così.

- il metodo ricevente agendo in un'area di memoria protetta, modifica il valore pervenutogli dal main

Il metodo ha in mano qualcosa di diverso da quello che gli è stato passato: una variabile di tipo primitivo che ha lo stesso valore di quella che è stata usata per chiamare il metodo, ma che punta ad una locazione di memoria diversa. Non è una questione di ricamo, la faccenda è molto diversa.

Dopo scrivo un paio di linee di codice per spiegarmi con più chiarezza.

- quando il metodo ricevente lo ritorna al metodo main, è il metodo main stesso che lo sostituisce col nuovo

Qui pare che la cosa sia automatica ma in realtà un metodo, sappiamo, non restituisce nulla se non è predisposto per farlo.

se è così è, boh, mi sembra un ottimo modo per proteggersi in quanto non possono due metodi alterare allo stesso tempo il medesimo valore

Ogni metodo ha un "lucchetto" attivabile proprio per evitare che due metodi agiscano insieme su uno stesso valore (dove valore è quello che sta in memoria, cioè un valore-oggetto o un valore-numerico o un valore-boolean). Qui pare che sia una bizzarria inventata da un matto per appensantire un po' le cose, non è cos', i metodi possono concretamente alterare allo stesso tempo lo stesso valore, se vengono chiamati "insieme" possono capitare guai sulla coerenza dei dati.

[PGI]

Procediamo un pezzo per volta.


Questo è il nostro "dato".

public class Contatto {
	public String nome = null;
	public String cognome = null;
	
	public Contatto(String nome, String cognome) {
		this.nome = nome;
		this.cognome = cognome;
	}
	
	public String toString() {
		return super.hashCode()+ " "+ nome + " " +cognome;
	}
}

1) Passaggio per riferimento (ogni volta che il parametro di un metodo è di tipo "reference" -> "riferimento")

public class Esperimento {
	/** main */
	public static void main(String... args) {
		new Esperimento().eseguiEsperimento();
	}
	
	
	public void eseguiEsperimento() {
		Contatto marioRossi = new Contatto("Mario", "Rossi");
		Contatto giulioBianchi = new Contatto("Giulio", "Bianchi");
		
		System.out.println("valore originale puntato");
		System.out.println(marioRossi);
		System.out.println(giulioBianchi);
		
		System.out.println("passaggio per riferimento");
		modificaPuntamento(marioRossi);
		modificaPuntamento(giulioBianchi);
		
		System.out.println("cosa e' cambiato ?");
		System.out.println(marioRossi);
		System.out.println(giulioBianchi);
	}
	
	public void modificaPuntamento(Contatto riferimento) {
		riferimento = new Contatto("Beppe", "Neri");
	}
}

L'output è:

valore originale puntato
17523401 Mario Rossi
8567361 Giulio Bianchi
passaggio per riferimento
cosa e' cambiato ?
17523401 Mario Rossi
8567361 Giulio Bianchi

Non è cambiato un bel cavolo.

Perchè? Due motivi:

1) passando un tipo-reference non passo il valore a cui il reference punta: se così fosse, infatti, creando nel metodo "modificaPuntamento" un nuovo oggetto ed assegnandolo al parametro, la variabile-reference originale (marioRossi) dovrebbe ritrovarsi puntata nella stessa locazione di memoria, la quale avrebbe tuttavia un valore diverso.

2) passando un tipo reference il metodo ottiene una copia del reference, cioè un nuovo tipo reference che punta alla stessa locazione di memoria. Assegnando a questa copia un nuovo valore, non viene chiaramente intaccato il valore originale di marioRossi. Se il reference ottenuto dal metodo modificaPuntamento fosse lo stesso reference "di partenza", o un puntatore al reference originale (puntatore ad un puntatore, che in Java non esiste), modificando "riferimento" dovrei ottenere un cambiamento riflesso in "marioRossi", che invece non c'è.

[PGI]

Proviamo con i primitivi?

public class Esperimento {
	/** main */
	public static void main(String... args) {
		new Esperimento().eseguiEsperimento();
	}
	
	
	public void eseguiEsperimento() {
		int intero = 10;
		System.out.println("prima del passaggio");
		System.out.println(intero);
		System.out.println("dopo il passaggio");
		passaggioPerValore(intero);
		System.out.println(intero);
	}
	
	public void passaggioPerValore(int primitivo) {
		primitivo = 20;
	}
}

prima del passaggio
10
dopo il passaggio
10

Cosa cambia? Un...un...cavolo.

Ed ecco la prima norma di coerenza che si ritrova in Java: il passaggio per valore (primitivo) e riferimento (reference) garantisce che il riassegnamento operato all'interno di un metodo produca lo stesso effetto (indifferenza rispetto al contenuto della variabile presente nel metodo chiamante).

Abbiamo visto che se i reference fossere passati per valore questo non succederebbe: e questo curiosamente non tutti lo scrivono (vedi Using Java 1.1, che parla di ambiguità, trascurando del tutto la parte del riassegnamento)

[PGI]

Adesso vediamo come produrre attraverso un metodo una modifica di un oggetto, passato per riferimento.

public class Esperimento {
	/** main */
	public static void main(String... args) {
		new Esperimento().eseguiEsperimento();
	}
	
	
	public void eseguiEsperimento() {
		Contatto marioRossi = new Contatto("Mario", "Rossi");
		System.out.println("Prima delle modifiche");
		System.out.println(marioRossi);
		System.out.println("Dopo le modifiche");
		modificaContenuto(marioRossi);
		System.out.println();
		System.out.println("Un modo per modificare tutto");
		System.out.println("Prima delle modifiche");
		System.out.println(marioRossi);
		System.out.println("Dopo le modifiche");
		marioRossi = modificaContatto(marioRossi);
		System.out.println(marioRossi);
	}
	
	public void modificaContenuto(Contatto contatto) {
		contatto.nome = "Beppe";
		contatto.cognome = "Neri";
	}
	
	public Contatto modificaContatto(Contatto contatto) {
		contatto = new Contatto(contatto.nome, "Calvi");
		return contatto;
	}
}

Prima delle modifiche
17523401 Mario Rossi
Dopo le modifiche

Un modo per modificare tutto
Prima delle modifiche
17523401 Beppe Neri
Dopo le modifiche
8567361 Beppe Calvi

modificaContenuto non restituisce nulla, ma cambia due campi all'interno dell'oggetto contatto: il cambiamento si riflette sul reference originale perchè la copia opera sulla stessa parte di memoria (dal codice hash si capisce che è lo stesso oggetto a cui puntava l'originale)

modificaContatto restituisce un diverso oggetto (si vede perchè è diverso il codice hash) il cui contenuto è in parte uguale a quello a cui puntava il riferimento. Il principio è lo stesso di quello dell'interfaccia "clone": questo approccio è però dispersivo, perchè "butta via" l'oggetto originale in memoria (dereferenziandolo), ne crea uno nuovo e lo "assegna" al riferimento originale (è un po' come funziona il "clone", nell'interfaccia Cloneable)

[cn73]

Bella lezione PGI

Vediamo se i tuoi alunni hanno capito:
Senza eseguire mi dite l'output di questo programmino?

class Referenza {
	
	static int a;
	static java.util.Vector vector;
	
	public static void main(String[] arg) {		
		
		a=1;
		System.out.println("a= : " + a); 
		modificaInt(a);
		System.out.println("a= : " + a); 
		
		vector=new java.util.Vector();
		System.out.println("size : " +vector.size());
		modificaVector(vector);
		System.out.println("size : " +vector.size());	
		modificaVectorPointer(vector);
		System.out.println("size : " +vector.size());	
		
	}
	
	static void modificaInt(int a){
		a--;
	}	
	
	static void modificaVector(java.util.Vector v){
		v.addElement(new Object());
	}
	
	static void modificaVectorPointer(java.util.Vector v){
		v=new java.util.Vector();
		v.addElement(new Object());
		v.addElement(new Object());
	}
	
}

[misterx]

vediamo se ho capito e tranquillo che non baro; il compilatore è OFF

class Referenza {
	
	static int a;
	static java.util.Vector vector;
	
	public static void main(String[] arg) {		
		
		a=1;
		System.out.println("a= : " + a);  a = 1
		modificaInt(a);
		System.out.println("a= : " + a); a = 1
		
		vector=new java.util.Vector();
		System.out.println("size : " +vector.size()); 1 // qui non so se new Vector aggiunge qualcosa al size se si, vale 1 altrimenti 0; di conseguenza quelli sotto valgono 1 tutti e due
		modificaVector(vector);
		System.out.println("size : " +vector.size()); 2	
		modificaVectorPointer(vector);
		System.out.println("size : " +vector.size()); 2	
		
	}
	
	static void modificaInt(int a){
		a--;
	}	
	
	static void modificaVector(java.util.Vector v){
		v.addElement(new Object());
	}
	
	static void modificaVectorPointer(java.util.Vector v){
		v=new java.util.Vector();
		v.addElement(new Object());
		v.addElement(new Object());
	}
	
}

[/quote]

[cn73]

La seconda che hai detto...new Vector crea un puntatore ad un oggetto di tipo Vector vuoto...perciò size è 0... per il resto ci siamo