[java] costrutto this e chiamata a metodi

[aria1984]

ciao a tutti....ho due domande....
1 a cosa serve this?
2 come si fa a chiamare un metodo di una classe in un altro metodo della stessa classe?
grazie
ps sn una studentessa di elettronica...cercate di spiegare in maniera comprensibilissima per un'ignorante in materia...
grazie a tutti.

[thebol]

Originariamente inviato da aria1984

ciao a tutti....ho due domande....
1 a cosa serve this?
2 come si fa a chiamare un metodo di una classe in un altro metodo della stessa classe?
grazie
ps sn una studentessa di elettronica...cercate di spiegare in maniera comprensibilissima per un'ignorante in materia...
grazie a tutti.

this serve a referenziare l'oggetto in cui stai lavorando.
esempio

nel tua classe dichiari una variabile di classe

int pippo = 1;

.

poi fai un metodo

public void metodo1(int pippo)
{
     system.out.println(pippo);
     system.out.println(this.pippo);
}

la prima chiamata restituira il valore della variabile pippo passata come parametro.
la seconda chiamata restituirà il valore della variabile pippo di classe.


altro esempio
fai una classe di nome pluto.

al suo interno fai un metodo che restituisce l'oggetto stesso

Pluto pluto = new Pluto();
Pluto pluto2 = pluto.getThis();

pluto == pluto2;

l'implementazione di getThis è

public Pluto getThis()
{
    return this;
}

[PGI-Bis]

Secondo le regole del linguaggio Java, le espressioni di accesso ad un membro di istanza (campi, metodi, tipi interni non annidati) necessitano di un riferimento su cui operare.

la parola chiave this (unqualified this) si riferisce ad un campo terminale il cui valore è l'istanza corrente della classe in cui compaia la parola chiave. Ha una doppia forma, qualificata e non qualificata. La forma qualificata è:

NomeClasse.this

e la non qualificata è:

this

La seconda è una semplificazione della prima ed il significato è determinato dal contesto. Il contesto determina anche la necessità d'uso della forma qualificata.

Fuor di specifiche, la cosa è molto più semplicemente descrivibile con un: this significa "sè stesso" (molti linguaggio usano self al posto di this come parola chiave per indicare lo stesso fenomeno).

Se invochi un metodo o accedi ad un campo devi sempre indicare il "proprietario" di quel metodo o di quel campo, anche quando l'invocazione o l'accesso siano richiesti dallo stesso oggetto che possiede il metodo invocato o il campo acceduto. Così un ipotetico Pippo:

public class Pippo {

    public String getParola() {
        return "Ciao!";
    }

    public void stampaLaTuaParola() {
        String parola = this.getParola();
        System.out.println(parola);
    }
}

volendo stampare il risultato di un metodo che pure sa di possedere deve comunque indicare che egli stesso è il possessore del metodo (getParola) che desidera invocare.

La particolare (presunta) frequenza con cui avvengono le "invocazioni a sè stesso" ha suggerito ai progettisti di Java l'omissibilità della parola chiave this.

Si tratta di una "cattiveria logica" perchè introduce un'eccezione alla regola dell'esplicita indicazione del riferimento per le espressioni d'accesso a membri di istanza che recita:

l'espressione di accesso ai membri di un'istanza inizia sempre con il nome della variabile che contiene il riferimento all'istanza che possiede il membro acceduto a meno che il membro acceduto non sia dichiarato nella stessa definizione di classe in cui avviene l'accesso o in un super tipo di quella classe: in questo caso il nome della variabile riferimento può essere omesso ed è implicitamente sostituito dalla parola chiave this.

Visto che si può omettere, ha senso averlo questo "this"?. Si, almeno in un caso.

I programmatori hanno grande fantasia ma a tutto c'è un limite. In particolare i nomi delle cose tendono ad esaurirsi in fretta oppure a volte proprio non viene in mente null'altro o, ancora, capita che si scontrino fantasie coincidenti.

Supponiamo di avere un mezzo-Pippo così fatto:

public class Pippo {
    private int quantità;
}

A questo Pippo aggiungiamo un metodo per impostare il valore del campo quantità:

public class Pippo {
    private int quantità;

    public void setQuantità(int quantità) {

Ora abbiamo un problema di conflitto di nomi: nel corpo del metodo setQuantità, il nome del parametro intero (quantità) adombra il nome del campo omonimo delle istanze di Pippo (quantità).

Qui emerge la differenza tra l'accesso ad un campo di istanza e l'accesso ad un parametro: entro l'ambito delle rispettive dichiarazioni di nome, il primo è fatto sempre attraverso un riferimento, il secondo sempre attraverso il nome del parametro. Ecco allora che a risolvere l'arcano basta rendere esplicito l'implicito:

public class Pippo {
    private int quantità;

    public void setQuantità(int quantità) {
        this.quantità = quantità;
    }
}

this.quantità è accesso ad un campo, lo sappiamo perchè prima del nome semplice del campo vediamo un riferimento (this). La parte a destra è potenzialmente accesso al campo quantità MA occorrendo il nome semplice quantità nell'ambito della dichiarazione del nome di parametro "int quantità" sappiamo che, ripeto a destra, stiamo "parlando" del parametro del metodo.

Più in generale, la parola chiave this, nella sua forma qualificata, risolve tutti i casi di adombramento che coinvolgano due nomi di membri di istanza, quando la dichiarazione adombrante appartenga ad un tipo interno non annidato del tipo che dichiara il nome adombrato.

Vale, ad esempio, per i nomi di metodo:

public class ExtraPippo {
    public String getFrase() { return "Ciao da extra pippo"; }

    public void parla() { System.out.println(getFrase()); }

    class IntraPippo() {
        public String getFrase() { return "Ciao da intra pippo"; }

        public void parla() {
            this.parla(); //this non qualificato
            ExtraPippo.this.parla(); //this qualificato
        }
    }
}

Caso diverso è il "this" che appare nell'espressione di invocazione di un costruttore alternato. A certe condizioni, un costruttore può invocare un altro costruttore. Tale invocazione è detta appunto invocazione di costruttore alternato e si esprime con:

<A>this(B)

dove A è un elenco di dichiarazioni di parametro per l'invocazione di costruttori generici e B è l'elenco di dichiarazioni di parametri attuali. Ad esempio:

public class SemprePippo {
    private String parola;

    public SemprePippo(String parola) {
        this.parola = parola;//this risolve l'adombramento tra parametro e campo
    }

    public SemprePippo() {
        this("default");//invocazione di costruttore alternato
    }
}