Il reference this

[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?