[JAVA] Uso della parola chiave "this" nei costruttori

[Darèios89]

Ho ben capito che viene usato nel costruttore per riferirsi alle variabili di istanza, però un altro uso è quello fatto per richiamare un altro costruttore.

In alcuni file ho visto:

public class Prezzo
{

private int prezzo;
Private int sconto;

public Prezzo(int prezzo, int sconto)
{
this.prezzo=prezzo;
this.sconto=sconto;
}

E fin qui....bene. Ma in quest' altro esempio:

public class Prezzo
{
private int prezzo;
private int sconto;

public Prezzo()
{
this(0,0)
}

Ora in questo caso intuisco che faccia un pò la stessa cosa che ho scritto nel primo esempio, ma quindi quando succede una cosa così com' è possibile che senza scrivere nulla automaticamente assegni quei valori alle variabili?
Cosa succede?

Vi chiederei di farmi un altro esempio in cui il this viene usato per richiamare un altro costruttore, o come viene usato in altri casi quando lo vedo messo tra le parentesi di un metodo.
Insomma, intanto questo, poi se mi spiegate chiaramente e con qualche esempio proprio tutot quanto ne sarei davvero felice

[andbin]

Originariamente inviato da Darèios89
Ho ben capito che viene usato nel costruttore per riferirsi alle variabili di istanza

Il this inteso come riferimento a "questo oggetto su cui sto lavorando" può essere usato non solo nel costruttore ma anche nei metodi.

Originariamente inviato da Darèios89

public class Prezzo
{
private int prezzo;
private int sconto;

public Prezzo()
{
this(0,0)
}

Ora in questo caso intuisco che faccia un pò la stessa cosa che ho scritto nel primo esempio, ma quindi quando succede una cosa così com' è possibile che senza scrivere nulla automaticamente assegni quei valori alle variabili?
Cosa succede?

Il this(0,0) invoca un costruttore in quella stessa classe che riceve i due int .... c'è? esiste? (non si vede nel pezzo di codice postato) Se sì ok. Se no è un errore di compilazione.

Originariamente inviato da Darèios89
Vi chiederei di farmi un altro esempio in cui il this viene usato per richiamare un altro costruttore

import java.awt.Color;

public class PuntoColorato {
    private int x;
    private int y;
    private Color colore;
    
    public PuntoColorato() {
        this(0, 0);
    }

    public PuntoColorato(int x, int y) {
        this(x, y, Color.BLACK);
    }
    
    public PuntoColorato(int x, int y, Color colore) {
        this.x = x;
        this.y = y;
        this.colore = colore;
    }

    // ... altro
}

E nota come il primo invoca il secondo e il secondo invoca il terzo. E i primi due passano uno o più "default" mentre l'ultimo è quello "completo" che assegna ai campi.
Nel primo costruttore si poteva anche invocare direttamente il terzo con this(0, 0, Color.BLACK); anche se così si ripeterebbe il default del colore. Questione di gusti ...

Ed è abbastanza comune/tipico fare cose di questo tipo per offrire una buona "flessibilità" nella costruzione degli oggetti.

Originariamente inviato da Darèios89
o come viene usato in altri casi quando lo vedo messo tra le parentesi di un metodo.

Questo l'hai già visto nel primo costruttore che hai postato. Il this fa riferimento all'oggetto su cui il metodo è stato invocato (o per il costruttore l'oggetto che è in "costruzione").

Generalmente il this usato in questo senso è superfluo. Una convenzione tipica è quella di usare nomi di parametri uguali a quelli dei campi (già anche solo per non stare ad inventarsi nuovi nomi) e in tal caso si deve usare this.campo per chiarire che si vuole il campo. Perché un parametro (di metodo/costruttore) "nasconde" il nome del campo con lo stesso nome.

[Darèios89]

Il tuo esempio l'ho capito, ma per quanto riguarda quello che ho scritto io ho un dubbio.
Il mio codice non compila, se prendo un altro codice e ne guardo la parte iniziale:

/* implementa una coda utilizzando un'array */

public class ArrayQueue<E> implements Queue<E>  {

	private int rear, front;
	private int size;
	private int n;
	private static final int CAPACITY = 100;
	private E[] Q;

	public ArrayQueue() {
		this(CAPACITY);
	}

	public ArrayQueue(int capacity) {
		rear = front = 0;
		size = 0;
		n = capacity;
		Q = (E[]) new Object[capacity]; //genera un'eccezione ma è ok
	}

	public boolean isEmpty() {
		if(size==0) return true;
		return false;
	}

	public int size() {
		return size;
	}

    public E front() throws EmptyQueueException{
		if (isEmpty()) throw new EmptyQueueException("Queue is empty.");
		return Q[front];
	}

	public void enqueue(E elem) {
		if(size()==n) throw new FullQueueException("Queue is full.");
		Q[rear] = elem;
		rear = (rear+1) % n;
	    size++;
	}


	public E dequeue() throws EmptyQueueException {
	    if (size == 0) throw new EmptyQueueException("Queue is empty.");
	    E tmp = Q[front];
		Q[front] = null;
		front = (front+1) % n;
	    return tmp;
	}
}

E' questo il codice che non capivo, perchè il primo costruttore dovrebbe impostare come default la capacità dello stack, ma ora che tu mi hai spiegato forse mi è chiaro.
La imposta di default con il valore CAPACITY perchè il primo costruttore richiama il secondo o sbaglio?

[andbin]

Originariamente inviato da Darèios89
La imposta di default con il valore CAPACITY perchè il primo costruttore richiama il secondo o sbaglio?

Sì, se invochi new ArrayQueue() (senza argomenti) esso invoca il secondo passando appunto la capacità di "default".

[Darèios89]

Mh, bene, ora un' ultima domanda un pò offtopic:

Ho letto dei costruttori telescopici, dove praticamente viene usato il this, esempio:

// Telescoping constructor pattern - does not scale well! - Pages 11-12

public class NutritionFacts {
    private final int servingSize;   // (mL)            required
    private final int servings;      // (per container) required
    private final int calories;      //                 optional
    private final int fat;           // (g)             optional
    private final int sodium;        // (mg)            optional
    private final int carbohydrate;  // (g)             optional

    public NutritionFacts(int servingSize, int servings) {
        this(servingSize, servings, 0);
    }

    public NutritionFacts(int servingSize, int servings,
            int calories) {
        this(servingSize, servings, calories, 0);
    }

    public NutritionFacts(int servingSize, int servings,
            int calories, int fat) {
        this(servingSize, servings, calories, fat, 0);
    }

    public NutritionFacts(int servingSize, int servings,
            int calories, int fat, int sodium) {
        this(servingSize, servings, calories, fat, sodium, 0);
    }

    public NutritionFacts(int servingSize, int servings,
           int calories, int fat, int sodium, int carbohydrate) {
        this.servingSize  = servingSize;
        this.servings     = servings;
        this.calories     = calories;
        this.fat          = fat;
        this.sodium       = sodium;
        this.carbohydrate = carbohydrate;
    }

    public static void main(String[] args) {
        NutritionFacts cocaCola =
            new NutritionFacts(240, 8, 100, 0, 35, 27);
    }
}

Praticamente sono delle chiamate a catena fino all'ultimo, ma mi chiedevo qual'è l'utilità dei costruttori telescopici.

[LeleFT]

Originariamente inviato da Darèios89
ma mi chiedevo qual'è l'utilità dei costruttori telescopici.

Quella di fornire un modo, a chi usa una classe, di non doversi preoccupare di passare tutte le informazioni necessarie alla costruzione dell'oggetto, ma solo quelle specifiche, lasciando il compito al costruttore di fornire i dettagli per i parametri necessari, che diventano così dei parametri "impliciti".

Esempio. Se ho una classe "Punto" che prevede due valori interi che rappresentano le coordinate sul piano cartesiano, posso pensare di dotare tale classe di un costruttore senza parametri che, implicitamente, costruisce un oggetto Punto posizionato all'origine. Questo costruttore, richiamerà quello con due parametri passando i valori di default (0, 0).

Senza questo costruttore, chiunque volesse costruire un oggetto Punto con coordinate all'origine, dovrebbe obbligatoriamente passare le due coordinate in modo esplicito al costruttore con due argomenti. La presenza del costruttore senza argomenti, semplifica la vita.

Inoltre, se la costruzione di un oggetto prevede di eseguire tante operazioni, usando i costruttori telescopici si scrive una sola volta il costruttore completo e tutti gli altri lo richiameranno. Alcuni vantaggi: si scrive il codice una sola volta (11° comandamento del programmatore: tu non riscriverai); eventuale manutenzione (debugging, ampliamento, ottimizzazione) la si fa solo su un costruttore.

Ciao.

[andbin]

Originariamente inviato da Darèios89
Ho letto dei costruttori telescopici, dove praticamente viene usato il this, esempio:

Praticamente sono delle chiamate a catena fino all'ultimo, ma mi chiedevo qual'è l'utilità dei costruttori telescopici.

Per costruttori "telescopici" si intende un insieme di costruttori in cui ognuno aggiunge un qualcosa di più (parametro/i aggiuntivo/i) rispetto a quelli con meno parametri.
Ma non è che questo implica l'uso del this .... non è mica detto. Cioè non è l'uso del this che rende il costruttore "telescopico".

Certo, è abbastanza naturale/logico che quelli con meno parametri possono invocare un altro con più parametri passando dei "default". Ma ripeto, non è la invocazione con this il concetto dei costruttori "telescopici".

[Darèios89]

Ok, grandissimi. Grazie.

Ai prossimi post..