this în Java

this.camp = parametru;   // câmpul obiectului curent
this(argumente);         // alt constructor al aceleiași clase
return this;             // obiectul curent

Ce face this

În interiorul unei metode sau al unui constructor, this înseamnă „obiectul pe care lucrez acum”. Cea mai des întâlnită folosire este this.nume = nume;: parametrul nume ascunde câmpul cu același nume, iar this.nume spune explicit că e vorba de câmp.

this(...), pe prima linie a unui constructor, apelează alt constructor al aceleiași clase. return this; returnează obiectul curent și permite apeluri înlănțuite (stil „fluent”): cos.adauga(...).adauga(...).

this poate fi trimis ca argument altor metode, de exemplu când un obiect se înregistrează singur într-o listă. Într-o metodă static nu există this, pentru că metoda nu este apelată pe un obiect.

Exemple

Exemplul 1: Câmp și parametru cu același nume

În constructor, this.nume este câmpul, iar nume este parametrul. În metoda descriere nu există conflict de nume, deci this. este opțional.

class Student {
    String nume;
    String facultate;

    Student(String nume, String facultate) {
        this.nume = nume;
        this.facultate = facultate;
    }

    String descriere() {
        return nume + " studiază la " + this.facultate;
    }
}

public class Main {
    public static void main(String[] args) {
        Student s = new Student("Ioana", "Informatică, UAIC Iași");
        System.out.println(s.descriere());
    }
}

Rezultat

Ioana studiază la Informatică, UAIC Iași

Exemplul 2: return this pentru apeluri înlănțuite

Fiecare adauga modifică obiectul și îl returnează, așa că următorul apel continuă pe același coș.

class Cos {
    private final StringBuilder continut = new StringBuilder();
    private double total;

    Cos adauga(String produs, double pret) {
        if (!continut.isEmpty()) {
            continut.append(", ");
        }
        continut.append(produs);
        this.total += pret;
        return this;
    }

    void afiseaza() {
        System.out.printf("%s => %.2f lei%n", continut, total);
    }
}

public class Main {
    public static void main(String[] args) {
        new Cos()
            .adauga("mere", 6.5)
            .adauga("brânză", 24.0)
            .adauga("pâine", 5.25)
            .afiseaza();
    }
}

Rezultat

mere, brânză, pâine => 35.75 lei

Exemplul 3: Obiectul se trimite singur cu this

La construcție, fiecare participant se înscrie în concurs trimițând this. Concursul primește referința către obiectul complet.

import java.util.ArrayList;
import java.util.List;

class Concurs {
    final List<Participant> inscrisi = new ArrayList<>();

    void inscrie(Participant p) {
        inscrisi.add(p);
    }
}

class Participant {
    final String nume;

    Participant(String nume) {
        this.nume = nume;
    }

    void inscrieLa(Concurs concurs) {
        concurs.inscrie(this);
    }
}

public class Main {
    public static void main(String[] args) {
        Concurs olimpiada = new Concurs();
        for (String nume : new String[] {"Andrei", "Bianca", "Cosmin"}) {
            new Participant(nume).inscrieLa(olimpiada);
        }
        for (Participant p : olimpiada.inscrisi) {
            System.out.println("înscris: " + p.nume);
        }
    }
}

Rezultat

înscris: Andrei
înscris: Bianca
înscris: Cosmin

Greșeli frecvente

• Scrii nume = nume; în constructor: compilatorul nu se plânge, dar câmpul rămâne null. Scrie this.nume = nume;.
• Folosești this într-o metodă static, de exemplu în main: non-static variable this cannot be referenced from a static context.
• Pui this(...) după cod care folosește obiectul. Apelul altui constructor trebuie să vină înaintea oricărei folosiri a obiectului curent.

Comenzi înrudite

• Constructori: Constructorul are numele clasei, nu are tip returnat și pregătește obiectul nou; o clasă poate avea mai mulți constructori.
• super: super apelează constructorul superclasei sau versiunea din superclasă a unei metode rescrise.
• static: static leagă un câmp sau o metodă de clasă, nu de un obiect: există o singură copie, accesată prin numele clasei.
• Clase și obiecte (class): O clasă (cuvântul cheie class) descrie un tip nou: câmpuri pentru date și metode pentru comportament; obiectele sunt instanțele ei.