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]

Vediamo se ho capito. Allora, relativamente a questo argomento ho fatto un esercizio. Questa è la traccia:

Creare una classe Risultato che dichiari una sola variabile d'istanza di tipo float e di nome risultato. Aggiungere eventuali metodi e costruttori utili. Creare una classe CambiaRisultato con un metodo public di nome cambiaRisultato() che prende in input un oggetto di tipo risultato e ne modifica la variabile interna risultato sommandola con un altro valore. Creare una classe con un metodo main() di nome TestRisultato che stampi la variabile risultato di un oggetto di tipo Risultato, prima e dopo che questo oggetto sia passato in input al metodo cambiaRisultato() di un oggetto di tipo CambiaRisultato.

la mia soluzione è questa:

public class TestRisultato
{
    public static void main(String args[])
    {
        Risultato oggetto1 = new Risultato();
        oggetto1.stampa();
        CambiaRisultato oggetto2 = new CambiaRisultato();
        oggetto2.cambiaRisultato(oggetto1);
    }
}

public class Risultato
{
    float risultato;
    
    public float somma(float valore)
    {
        risultato = risultato + valore;
        return(risultato);
    }
    
    public void stampa()
    {
        System.out.println(risultato);
    }
}

public class CambiaRisultato
{
    public void cambiaRisultato(Risultato oggetto)
    {
        oggetto = new Risultato();
        oggetto.somma(10);
        oggetto.stampa();
    }    
}

E' corretto dire che le righe di codice che ho evidenziato sono esattamente quelle che permettono all'oggetto2 di puntare alla locazione di memoria di oggetto1? Inoltre direi che in particolar modo è proprio new Risultato() presente nel metodo cambiaRisultato ad "indicare" a oggetto2 dove deve puntare.
Sono corrette queste considerazioni?

[andbin]

E' corretto dire che le righe di codice che ho evidenziato sono esattamente quelle che permettono all'oggetto2 di puntare alla locazione di memoria di oggetto1? Inoltre direi che in particolar modo è proprio new Risultato() presente nel metodo cambiaRisultato ad "indicare" a oggetto2 dove deve puntare.
Sono corrette queste considerazioni?

Il metodo cambiaRisultato riceve il riferimento ad un oggetto Risultato. Questo oggetto NON lo stai utilizzando in alcun modo, perché al parametro assegni subito un altro (nuovo) oggetto Risultato.
Quindi, onestamente, l'esempio che hai fatto ha poco/nessun senso.

[newutente]

Concettualmente mi è chiaro, il problema che ho in questo momento è la comprensione del codice.
Mi sa che mi sto perdendo in un bicchier d'acqua.
Vediamo se riesco a schemattizare le idee che ho in questo momento, seppur fatto in maniera "meccanica".
Allora, se ho la necessità di far puntare due oggetti dello stesso tipo alla stessa locazione di memoria devo utilizzare istruzioni di questo tipo:

Data oggetto1 = new Data();
Data oggetto2 = oggetto1;

altrimenti, se ho la necessità di far puntare due oggetti di tipo diverso alla stessa locazione di memoria devo necessariamente utilizzare queste istruzioni:

...
Data2 oggetto2 = new Data2();
Data oggetto1 = new Data();
oggetto2.cambiaReference(oggetto1);
...

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

E' corretto?