utilizzo dei reference

[newutente]

C'è qualcosa che non mi torna su un esercizio riguardante l'utilizzo dei reference.
La traccia dell'esercizio è la seguente:

Utilizzare una classe Persona che dichiara le variabili nome, cognome, eta. Si dichiari inoltre il metodo dettagli() che restituisca in una stringa le informazioni sulla persona in questione.
Utilizzare una classe Principale che, nel metodo main(), istanzia due oggetti chiamati persona1 e persona2 della classe Persona, inizializzando per ognuno di essi i relativi campi adoperando l'operatore dot.
Dichiarare un terzo reference (persona3) che punti ad uno degli oggetti già istanziati. Controllare che effettivamente persona3 punti all'oggetto voluto, stampando i campi di persona3 sempre tramite l'operatore dot.
Commentare adeguatamente le classi realizzate e sfruttare lo strumento javadoc per produrre la relativa documentazione.

La mia soluzione è questa:

/**
definizione della classe Principale    
*/
public class Principale
{
    public static void main(String args[])
    {
        Persona persona1 = new Persona(); /**creazione oggetto persona1*/
        persona1.nome = "mario";    /**assegnazione di uno specifico valore al campo nome*/
        persona1.cognome = "rossi";    /**assegnazione di uno specifico valore al campo cognome*/
        persona1.eta = 30;        /**assegnazione di uno specifico valore al campo data*/
        persona1.dettagli();        /**invocazione del metodo dettagli per stampare le generalità della persona*/
        Persona persona2 = new Persona();
        persona2.nome = "giovanni";
        persona2.cognome = "bruni";
        persona2.eta = 40;
        persona2.dettagli();
        Persona persona3 = persona1;    /**in questo modo l'oggetto persona3 punto ad un oggetto creato in precedenza ma i cui campi non sono ancora inizializzati*/
        persona3.dettagli();
    }
}

/**
definizione della classe Persona
*/
public class Persona
{

    /**
    definizione delle variabile d'istanza
    */
    public String nome;
    public String cognome;
    public int eta;

    
    /**
    definizione del metodo dettagli che permette di restituire una stringa con i dettagli della persona
    */
    public String dettagli()
    {
        String dettagli = nome + " " + cognome + " " + eta;
        System.out.println(dettagli);
        return(dettagli);    
    }
}

I miei dubbi sono:
1) Non ci sono errori in compilazione però l'output generato a mio avviso è errato:

mario rossi 30
giovanni bruni 40
mario rossi 30

è errato poichè restituisce di nuovo "mario rossi 30" nonostante l'oggetto persona3 punta a persona1 che è creato con un costruttore di default che dovrebbe inizializzare le variabili d'istanza con i valori di default e non con quelli inseriti tramite l'operatore dot.





2) ho generato la javadoc ma non sono certo che i commenti vadano inseriti in quel modo per generare una corretta javadoc.

[andbin]

public class Persona
{
    public String nome;
    public String cognome;
    public int eta;
.......

Iniziamo da questo: fintanto che fai questi esercizietti semplici (e finché nessuno ti "boccia" l'esercizio per questo) puoi anche mettere campi pubblici e accederci direttamente.
Ma cerca di abituarti a tenere i campi generalmente sempre private e a mettere appositi costruttori e metodi getter e/o setter.

1) Non ci sono errori in compilazione però l'output generato a mio avviso è errato:


è errato poichè restituisce di nuovo "mario rossi 30" nonostante l'oggetto persona3 punta a persona1 che è creato con un costruttore di default che dovrebbe inizializzare le variabili d'istanza con i valori di default e non con quelli inseriti tramite l'operatore dot.

Persona persona3 = persona1; /**in questo modo l'oggetto persona3 punto ad un oggetto creato in precedenza ma i cui campi non sono ancora inizializzati*/

No, vuol semplicemente dire che persona3 ha lo stesso valore (il reference) che ha persona1. E quindi entrambe le variabili fanno riferimento allo stesso identico oggetto.
Visto che l'oggetto l'hai inizializzato prima, lo "vedi" con quegli stessi dati sia attraverso persona1 che attraverso persona3.

2) ho generato la javadoc ma non sono certo che i commenti vadano inseriti in quel modo per generare una corretta javadoc.

Tecnicamente è corretto mettere /** .... */ (questo è appunto un commento "javadoc") ma documentare con javadoc significa anche di più di quello: come minimo documentare eventuali parametri e il tipo di ritorno (se non void). Poi anche eccezioni, se necessario.
Ti suggerisco di guardare i sorgenti del framework standard o di qualunque applicazione/libreria open-source che sia seria e ben fatta per poter vedere come scrivere i commenti javadoc.

EDIT: vedi ad esempio il sorgente di CharUtils.java della nota libreria Apache Commons Lang e il rispettivo javadoc CharUtils generato.

    public String dettagli()
    {
        String dettagli = nome + " " + cognome + " " + eta;
        System.out.println(dettagli);
        return(dettagli);    
    }

E aggiungo: in metodi come questo, è bene fare una cosa sola, o fornisci solo una stringa, o stampi solo una stringa. Entrambe le cose non va molto bene.

[newutente]

Iniziamo da questo: fintanto che fai questi esercizietti semplici (e finché nessuno ti "boccia" l'esercizio per questo) puoi anche mettere campi pubblici e accederci direttamente.
Ma cerca di abituarti a tenere i campi generalmente sempre private e a mettere appositi costruttori e metodi getter e/o setter.

Seguirò il tuo consiglio. Fino ad ora non ho utilizzato altri modificatori perchè non li ho incontrati ma sarà fatto.
Per quanto riguarda i metodi set e get intendi ad esempio per settare (tramite il metodo set) il valore di una determinata variabile e per restituirlo (tramite il metodo get)?

No, vuol semplicemente dire che persona3 ha lo stesso valore (il reference) che ha persona1. E quindi entrambe le variabili fanno riferimento allo stesso identico oggetto.
Visto che l'oggetto l'hai inizializzato prima, lo "vedi" con quegli stessi dati sia attraverso persona1 che attraverso persona3.

Ah ecco, ora il senso mi è più chiaro.
Comunque prima non capivo il perchè mi restituiva nuovamente i dettagli di persona1 perchè mi era sembrato di leggere nella traccia "Controllare che effettivamente persona3 punti all'oggetto vuoto" anzichè "voluto" e quindi mi aspettavo valori di default. Scusate.

Io però continuo a non capire che senso ha utilizzare i reference. Per evitare di utilizzare nuovamente l'operatore dot se voglio che il mio oggetto punti ad un altro già creato e che quindi abbia lo stesso valore?

Tecnicamente è corretto mettere /** .... */ (questo è appunto un commento "javadoc") ma documentare con javadoc significa anche di più di quello: come minimo documentare eventuali parametri e il tipo di ritorno (se non void). Poi anche eccezioni, se necessario.
Ti suggerisco di guardare i sorgenti del framework standard o di qualunque applicazione/libreria open-source che sia seria e ben fatta per poter vedere come scrivere i commenti javadoc.

EDIT: vedi ad esempio il sorgente di CharUtils.java della nota libreria Apache Commons Lang e il rispettivo javadoc CharUtils generato.

Ora mi è tutto molto più chiaro. Grazie.
Solo una domanda. Se all'interno di un metodo vado a dichiarare una variabile locale questa sarà presa in considerazione all'interno della javadoc? Io, volendo darmi una risposta, direi "solo se nella riga precedente alla dichiarazione c'è un commento javadoc".

E aggiungo: in metodi come questo, è bene fare una cosa sola, o fornisci solo una stringa, o stampi solo una stringa. Entrambe le cose non va molto bene.

ma quando mi dice "... che restituisca una stringa" si riferisce SOLO alla return? Io l'ho inteso come una stampa, oltre alla return, ma credo sia sbagliato a questo punto.

[andbin]

Per quanto riguarda i metodi set e get intendi ad esempio per settare (tramite il metodo set) il valore di una determinata variabile e per restituirlo (tramite il metodo get)?

Sì, tipo:

private String cognome;

public String getCognome() {
    return cognome;
}

public void setCognome(String cognome) {
    this.cognome = cognome;
}

Io però continuo a non capire che senso ha utilizzare i reference. Per evitare di utilizzare nuovamente l'operatore dot se voglio che il mio oggetto punti ad un altro già creato e che quindi abbia lo stesso valore?

In Java un reference è un valore. Solo che invece di essere un valore numerico che puoi manipolare, stampare ecc..., per il programmatore Java un reference è un qualcosa di molto "opaco". Non sai che valore ha, non sai nemmeno quanto un reference occupa in bit (dipende dalla piattaforma e dalla implementazione della JVM). Sai solo che o fa riferimento ad un oggetto, oppure è null ovvero non fa riferimento ad un oggetto.
Più variabili di tipo reference possono avere lo stesso valore, appunto lo stesso reference, quindi faranno riferimento allo stesso oggetto. Tutto qui.

Solo una domanda. Se all'interno di un metodo vado a dichiarare una variabile locale questa sarà presa in considerazione all'interno della javadoc?

No, javadoc non documenta il "comportamento" dei metodi, quindi non mostra nulla relativo al corpo del metodo.

Per variabili di classe e di istanza sì, la documentazione javadoc è possibile.

ma quando mi dice "... che restituisca una stringa" si riferisce SOLO alla return? Io l'ho inteso come una stampa, oltre alla return, ma credo sia sbagliato a questo punto.

Sì, o solo componi e restituisci una stringa, oppure fai un metodo con return void che stampa solo la stringa.

[newutente]

grazie per i chiarimenti.

In Java un reference è un valore. Solo che invece di essere un valore numerico che puoi manipolare, stampare ecc..., per il programmatore Java un reference è un qualcosa di molto "opaco". Non sai che valore ha, non sai nemmeno quanto un reference occupa in bit (dipende dalla piattaforma e dalla implementazione della JVM). Sai solo che o fa riferimento ad un oggetto, oppure è null ovvero non fa riferimento ad un oggetto.
Più variabili di tipo reference possono avere lo stesso valore, appunto lo stesso reference, quindi faranno riferimento allo stesso oggetto. Tutto qui.

scusa se insisto ma continuo a non capire.
Inserisco un esempio del capitolo del manuale relativo ai reference:

public class CiProvoConIReference
{
        public void cambiaReference(Data data)
        {
                  data = new Data();
        }
}

CiProvoConIReference ogg = new CiProvoConIReference();
Data dataDiNascita = new Data();
dataDiNascita.giorno = 14;
dataDiNascita.mese = 4;
dataDiNascita.anno = 2004;
ogg.cambiaReference(dataDiNascita);
System.out.println("Data di nascita = " + dataDiNascita.giorno + "-" + dataDiNascita.mese + "-" + dataDiNascita.anno);

e l'output è questo:

Data di nascita = 14-4-2004

Quello che non capisco è:
1) il metodo cambiaReference se non ho capito male si limita a dichiarare (prendendolo in input) un oggetto e ad istanziarlo. Ma allora come fa ad essere restituito quell'output se nel codice viene invocato il metodo dando in input sempre l'oggetto dataDiNascita? In teoria quell'oggetto a quel punto non dovrebbe essere sovrascritto e le variabili assumere valori nulli?

2) in quale pezzo del codice si vede l'utilizzo dei reference? Faccio questa domanda perchè in un altro esempio si notava chiaramente l'utilizzo.
L'esempio è questo:

Data unGiorno = new Data();
Data unAltroGiorno = unGiorno;

Quindi viene creato il primo oggetto (unGiorno) e poi viene dichiarato un altro oggetto (unAltroGiorno) che punterà all'oggetto creato prima.
Nell'esempio di prima questo non lo vedo.

[andbin]

scusa se insisto ma continuo a non capire.

Quello che non capisco è:
1) il metodo cambiaReference se non ho capito male si limita a dichiarare (prendendolo in input) un oggetto e ad istanziarlo. Ma allora come fa ad essere restituito quell'output se nel codice viene invocato il metodo dando in input sempre l'oggetto dataDiNascita? In teoria quell'oggetto a quel punto non dovrebbe essere sovrascritto e le variabili assumere valori nulli?

Il "data" del metodo cambiaReference è un parametro ma sostanzialmente è una variabile "locale" al metodo. Ed è differente dalla variabile "dataDiNascita" che c'è nel chiamante.
Ci sono quindi 2 variabili, una nel chiamante, l'altra nel metodo cambiaReference. All'inizio fanno riferimento allo stesso oggetto (perché il parametro ovviamente riceve una copia del valore). Se nel metodo assegni qualcosa al parametro, NON cambi il valore che ha la variabile "dataDiNascita" nel chiamante!

2) in quale pezzo del codice si vede l'utilizzo dei reference?

Dovunque usi una variabile che ha tipo: array, classe, interfaccia, enum, annotazione ..... fai un uso dei reference.

[newutente]

EDIT

[newutente]

Quindi, con l'istruzione

Data oggetto1 = new Data();

io ho dichiarato prima una variabile e successivamente ho istanziato un oggetto. In questo modo la variabile punterà alla locazione di memoria dove si trova oggetto1, in poche parole conterrà l'indirizzo di memoria dove si trova oggetto1.

Con l'istruzione

Data oggetto2 = oggetto1;

vado a dichiarare una seconda variabile ma anzichè farla puntare ad una locazione di memoria di un nuovo oggetto (questo non avviene perchè non c'è new Data()) le passo l'indirizzo di memoria dove si trova l'oggetto1 creato in precedenza.
Quindi ci sono due variabili (oggetto1 e oggetto2) che contengono lo stesso indirizzo di memoria e a quell'indirizzo di memoria si trova l'oggetto oggetto1.

Se poi ci fosse una terza riga di codice del tipo

Data oggetto2 = new Data();

vorrebbe dire che abbiamo fatto in modo ora che la seconda variabile non punti più alla locazione di memoria dove si trova oggetto1 ma è stato creato un nuovo oggetto e che quindi la seconda variabile punta alla locazione di memoria del nuovo oggetto.

E' corretto?

[LeleFT]

Quindi, con l'istruzione
E' corretto?

Quasi tutto...

L'eventuale terza riga non dovrebbe ri-dichiarare la variabile "oggetto2", perchè già dichiarata precedentemente... altrimenti il compilatore darebbe un errore "oggetto2 is already defined". Per il resto mi pare corretto.


Ciao.

[newutente]

Vediamo se ho capito anche il resto. Torniamo all'esempio che ho inserito nel post #5.

Quindi con

ogg.cambiaReference(dataDiNascita)

è come se dicessi "prendi la variabile dataDiNascita che contiene l'indirizzo di memoria dove si trova l'oggetto e che quindi contiene i campi giorno, mese e anno con già i valori all'interno inseriti nelle righe precedenti".
Tra l'altro il senso del metodo cambiaReference è appunto quello di cambiare il valore (forse sarebbe corretto dire l'indirizzo di memoria) di ogg perchè fino a quel momento ogg è una variabile che contiene l'indirizzo di una locazione di memoria diversa da dataDiNascita visto che sono state fatte due istanziazioni differenti nelle prime due righe:

CiProvoConIReference ogg = new CiProvoConIReference();
Data dataDiNascita = new Data();

successivamente con il blocco di codice

public class CiProvoConIReference
{
        public void cambiaReference(Data data)
        {
                  data = new Data();
        }
}

è come se dicessi "lascia perdere quella locazione di memoria, crea un nuovo oggetto in modo che la variabile ogg non contenga l'indirizzo di memoria dove si trova dataDiNascita ma l'indirizzo di memoria dove si trova un nuovo oggetto che è inizializzato con valori di default". Per questa ragione dataDiNascita contiene ancora i valori inseriti in precedenza.

E' corretto?