Il reference this

[Stark89]

Salve,ho iniziato a studiare Java da 0,è il primo linguaggio a oggetti che approccio,ho qualche base di C che ho studiato a scuola,devo dire che i concetti sono veramente tanti e faccio fatica a comprenderne così tanti tutti insieme, sto studiando poco per volta,sono arrivato all'incapsulamento,sto trovando difficoltà con la keyword this applicata ai costruttori,non riesco a capirne l'effettiva utilità e come funziona esattamente ecco qualche esempio:

public class Persona {
private String nome;
public void setNome(String nome){
this.nome=nome;
}
}

In questo caso this rende più chiaro il codice dandoci la possibilità di usare lo stesso nome sia per il parametro del metodo che per la variabile d'istanza.

In questo invece non riesco a capirne l'utilitá

public class Persona {
private String nome;
private String cognome;
public Persona() {
System.out.println("Sono il costruttore di default.");
}
public Persona(String nome) {
this(); // Chiama il costruttore senza parametri
this.nome=nome;
}
public Persona(String nome, String cognome) {
this(nome); // Chiama il costruttore con un parametro
this.cognome=cognome;
}
}

Qualcuno me lo sa spiegare in parole semplici ?

Grazie mille.

[andbin]

devo dire che i concetti sono veramente tanti e faccio fatica a comprenderne così tanti tutti insieme

Ci vuole tempo e studio, non devi preoccuparti se subito non riesci ad afferrare tutto. I concetti sono veramente tantissimi, è vero, senza parlare poi delle ultimissime novità di Java 7 e Java 8.
Come per tante altre cose, continua nello studio, vedrai che man mano avrai le idee sempre più chiare. Te lo dico per esperienza personale.

In questo caso this rende più chiaro il codice dandoci la possibilità di usare lo stesso nome sia per il parametro del metodo che per la variabile d'istanza.

Sì, la convenzione comune è di usare per un parametro lo stesso nome del campo e poi usare this per qualificare il campo. Questo perché il parametro effettua uno shadowing (in pratica nasconde) il nome del campo. Per questo è necessario qualificare il campo con this.
Tutto questo più che altro per non doversi "inventare" nomi strampalati per i parametri, che potrebbero essere non buoni o peggio fuorvianti per chi legge anche solo la documentazione javadoc di una classe.

In questo invece non riesco a capirne l'utilitá

In generale: all'interno di metodi di istanza o all'interno di un costruttore il this rappresenta il riferimento all'oggetto su cui è stato invocato il metodo di istanza (o l'oggetto in costruzione, se nel costruttore).

Ma la parola chiave this ha anche un altro uso: per invocare da un costruttore (come prima istruzione!) un altro costruttore della stessa classe.

[Stark89]

Ci vuole tempo e studio, non devi preoccuparti se subito non riesci ad afferrare tutto. I concetti sono veramente tantissimi, � vero, senza parlare poi delle ultimissime novit� di Java 7 e Java 8.
Come per tante altre cose, continua nello studio, vedrai che man mano avrai le idee sempre pi� chiare. Te lo dico per esperienza personale.

Lo spero,devo dire che mi sto scoraggiando,anche capendo i concetti(me ne mancano molti fondamentali) quando provo a scrivere qualcosa,qualche riga di codice, mi sento spaesato, non so da dove partire.

Sto studiando su un manuale java 8 e su html.it alternandoli quando i concetti mi sono poco chiari,ho sempre amato la programmazione a scuola ho studiato il C anche se in maniera non approfondita,mi sono diplomato in perito informatico,tuttavia a cause di forza maggiore non ho potuto continuare e ho dovuto ripiegare sul lavoro in tutt'altro ambito, in mio sogno é programmare in java e sviluppare app android,magari trovo anche qualche posto di lavoro come programmatore,un sogno che per� vedo molto difficile da realizzare

In generale: all'interno di metodi di istanza o all'interno di un costruttore il this rappresenta il riferimento all'oggetto su cui � stato invocato il metodo di istanza (o l'oggetto in costruzione, se nel costruttore).

Ma la parola chiave this ha anche un altro uso: per invocare da un costruttore (come prima istruzione!) un altro costruttore della stessa classe.

questa � la teoria, nell'esempio che ti ho postato viene richiamato 3 volte il costruttore,non riesco a capire il senso di questa cosa.

Nel primo stampa, tutto ok.

nel secondo gli passa la stringa nome e ok, poi usa

this(); che significa?

dopodiche

this.nome=nome;

dice che la stringa parametro nome � uguale alla stringa nome della classe.

nel terzo
passa nome e cognome come parametri e poi
this(nome);

nemmeno qui capisco,scusa l'ignoranza forse � semplice ma non ne vengo a capo. Grazie ancora

[andbin]

Lo spero,devo dire che mi sto scoraggiando,anche capendo i concetti(me ne mancano molti fondamentali) quando provo a scrivere qualcosa,qualche riga di codice, mi sento spaesato, non so da dove partire.

Capisco ma ti assicuro che non è il caso di scoraggiarsi. Basta continuare ed impegnarsi un po' e pian piano avrai le idee più chiare.

nemmeno qui capisco,scusa l'ignoranza forse � semplice ma non ne vengo a capo. Grazie ancora

Il this usato con le parentesi es. this(); o this( ...argomenti ... ); si può usare come prima (e solo la prima e basta) istruzione di un costruttore per invocare un altro costruttore della stessa classe.
Lo si fa generalmente per comodità quando c'è già un altro costruttore della classe che fa al caso, magari per passare una parte di dati iniziali o dei valori predefiniti.

Ti faccio un esempio:

public class Libro {
    private String titolo;
    private String editore;

    public Libro(String titolo, String editore) {
        this.titolo = titolo;
        this.editore = editore;
    }

    // altro ....
}

Il costruttore è corretto così. I nomi dei parametri sono gli stessi dei campi. Quindi all'interno del costruttore il nome semplice 'titolo' è il parametro, NON il campo. Se vuoi accedere al campo lo devi qualificare con this.

Quindi il senso è:
- il valore del parametro titolo lo assegno al campo titolo
- il valore del parametro editore lo assegno al campo editore

Quindi potrei usarlo da qualche altra parte es.

Libro libroJavaIO = new Libro("Java I/O, Second Edition", "O'Reilly Media");

Magari ci possono essere dei casi in cui si vuole creare un oggetto Libro senza dover specificare subito l'editore (che magari si può impostare successivamente tramite un metodo che non ho messo per brevità). Si può aggiungere un costruttore del tipo:

    public Libro(String titolo) {
        this(titolo, "Editore sconosciuto");
    }

In questo caso sfrutto l'altro costruttore che c'è già, semplicemente passando un valore predefinito per l'editore. Quindi la invocazione

this(titolo, "Editore sconosciuto");

invoca materialmente l'altro costruttore passando a sua volta il parametro titolo e un valore fisso per l'editore.

A quel punto si può usare con es.

Libro libro = new Libro("Java 8");

[Stark89]

Capisco ma ti assicuro che non è il caso di scoraggiarsi. Basta continuare ed impegnarsi un po' e pian piano avrai le idee più chiare.


Il this usato con le parentesi es. this(); o this( ...argomenti ... ); si può usare come prima (e solo la prima e basta) istruzione di un costruttore per invocare un altro costruttore della stessa classe.
Lo si fa generalmente per comodità quando c'è già un altro costruttore della classe che fa al caso, magari per passare una parte di dati iniziali o dei valori predefiniti.

Ti faccio un esempio:

public class Libro {
    private String titolo;
    private String editore;

    public Libro(String titolo, String editore) {
        this.titolo = titolo;
        this.editore = editore;
    }

    // altro ....
}

Il costruttore è corretto così. I nomi dei parametri sono gli stessi dei campi. Quindi all'interno del costruttore il nome semplice 'titolo' è il parametro, NON il campo. Se vuoi accedere al campo lo devi qualificare con this.

Quindi il senso è:
- il valore del parametro titolo lo assegno al campo titolo
- il valore del parametro editore lo assegno al campo editore

Quindi potrei usarlo da qualche altra parte es.

Libro libroJavaIO = new Libro("Java I/O, Second Edition", "O'Reilly Media");

Magari ci possono essere dei casi in cui si vuole creare un oggetto Libro senza dover specificare subito l'editore (che magari si può impostare successivamente tramite un metodo che non ho messo per brevità). Si può aggiungere un costruttore del tipo:

    public Libro(String titolo) {
        this(titolo, "Editore sconosciuto");
    }

In questo caso sfrutto l'altro costruttore che c'è già, semplicemente passando un valore predefinito per l'editore. Quindi la invocazione

this(titolo, "Editore sconosciuto");

invoca materialmente l'altro costruttore passando a sua volta il parametro titolo e un valore fisso per l'editore.

A quel punto si può usare con es.

Libro libro = new Libro("Java 8");

continuo a non capire

this quindi è una scorciatoia per non riscrivere sempre il costruttore ?

    public Libro(String titolo) {
        this(titolo, "Editore sconosciuto");
    }

equivale a scrivere

    public Libro(String titolo) {
    
    }
              public Libro(String editore) {
       
    }

[andbin]

continuo a non capire

Hai parlato del "C", sai sicuramente che in C una funzione può ovviamente invocare un'altra funzione. In Java un metodo può invocare un altro metodo. E in modo concettualmente similare, in Java un costruttore può invocare un altro costruttore.
Ed è appunto questo il senso del this( ); con o senza argomenti: poter invocare un altro costruttore.

Se poi ti chiedi il perché, beh ci possono essere motivazioni di comodità/praticità. Se nella classe Libro volessi mettere nel costruttore dei controlli (es. il titolo non può essere più lungo di 100 caratteri), logging o altro, tutto questo lo metto solo nel costruttore più completo, quello che riceve titolo e editore.
Nell'altro dove ho usato this(titolo, "Editore sconosciuto"); NON metto nulla di questo. Invocando il costruttore completo, riutilizzo la sua logica, senza dover riscrivere controlli e altro.

Se hai un minimo di esperienza nella programmazione sai che gli aspetti di riutilizzo del codice e il non dover replicare/sparpagliare del codice, sono molto importanti.

[Stark89]

Hai parlato del "C", sai sicuramente che in C una funzione può ovviamente invocare un'altra funzione. In Java un metodo può invocare un altro metodo. E in modo concettualmente similare, in Java un costruttore può invocare un altro costruttore.
Ed è appunto questo il senso del this( ); con o senza argomenti: poter invocare un altro costruttore.

Se poi ti chiedi il perché, beh ci possono essere motivazioni di comodità/praticità. Se nella classe Libro volessi mettere nel costruttore dei controlli (es. il titolo non può essere più lungo di 100 caratteri), logging o altro, tutto questo lo metto solo nel costruttore più completo, quello che riceve titolo e editore.
Nell'altro dove ho usato this(titolo, "Editore sconosciuto"); NON metto nulla di questo. Invocando il costruttore completo, riutilizzo la sua logica, senza dover riscrivere controlli e altro.

Se hai un minimo di esperienza nella programmazione sai che gli aspetti di riutilizzo del codice e il non dover replicare/sparpagliare del codice, sono molto importanti.

ah ecco ora mi è chiaro , allora come avrai capito ora ho un sacco di concetti in testa, di esperienza non ne ho molta e ora come ora tendo a fare confusione.
Un metodo può richiamare un altro metodo lo so,quindi scrivendo this(); come prima istruzione di un costruttore,ne richiamo un altro della stessa classe(o lo stesso?), passandogli magari qualche parametro e risparmiando di riscrivere altro codice?

quindi il comando this non farà altro che far eseguire tutte le istruzioni contenuto nel costruttore richiamato


giusto?

[andbin]

Esatto. E alla fine il concetto è tutto qui. Se in C hai già scritto una funzione che riceve un tot di parametri e invoca un'altra funzione passandoli tutti o qualcuno in meno o con qualche dato fisso in più... allora capisci il senso.

Nel caso dei costruttori, come per i metodi, chiaramente il compilatore verifica che la invocazione sia lecita ed applicabile.

Se nel costruttore Libro(String titolo) faccio

this(titolo, "Editore sconosciuto");

sto cercando di invocare un costruttore che riceve 2 String. Esiste un tale costruttore?
Certo, il compilatore vede che c'è un

Libro(String titolo, String editore)

Stop, punto. Per il compilatore l'altro costruttore è applicabile e la invocazione è quindi lecita.

[Stark89]

Esatto. E alla fine il concetto è tutto qui. Se in C hai già scritto una funzione che riceve un tot di parametri e invoca un'altra funzione passandoli tutti o qualcuno in meno o con qualche dato fisso in più... allora capisci il senso.

Nel caso dei costruttori, come per i metodi, chiaramente il compilatore verifica che la invocazione sia lecita ed applicabile.

Se nel costruttore Libro(String titolo) faccio

this(titolo, "Editore sconosciuto");

sto cercando di invocare un costruttore che riceve 2 String. Esiste un tale costruttore?
Certo, il compilatore vede che c'è un

Libro(String titolo, String editore)

Stop, punto. Per il compilatore l'altro costruttore è applicabile e la invocazione è quindi lecita.

A questo punto mi chiedo a cosa serve richiamare un costruttore uno dopo l'altro, sai farmi un esempio ?

[andbin]

A questo punto mi chiedo a cosa serve richiamare un costruttore uno dopo l'altro, sai farmi un esempio ?

Ma l'ho fatto prima l'esempio: voglio permettere di creare un oggetto Libro non solo con titolo+editore espliciti ma anche con solo titolo (e con un editore implicito predefinito).
Magari voglio gestire tutta una serie di validazioni, ad esempio che il titolo non sia null e non più lungo di 100 caratteri e l'editore non null e non più di 50 caratteri.

public class Libro {
    private String titolo;
    private String editore;

    public Libro(String titolo, String editore) {
        if (titolo == null) {
            throw new IllegalArgumentException("titolo non può essere null");
        }

        if (titolo.length() > 100) {
            throw new IllegalArgumentException("titolo non può essere lungo più di 100 caratteri");
        }

        if (editore == null) {
            throw new IllegalArgumentException("editore non può essere null");
        }

        if (editore.length() > 50) {
            throw new IllegalArgumentException("editore non può essere lungo più di 50 caratteri");
        }

        this.titolo = titolo;
        this.editore = editore;
    }

    public Libro(String titolo) {
        this(titolo, "Editore sconosciuto");
    }

    // altro ....
}

Tutta la validazione e la assegnazione ai campi la metto nel costruttore generale, il primo. Il secondo è solo una comodità che passa un valore predefinito per l'editore. Ma sfrutta appunto tutta la logica del primo costruttore che invoca.
NON c'è bisogno quindi di replicare (pessima cosa) la validazione in entrambi i costruttori!