Java dit zoekwoord

In dit artikel zullen we met behulp van voorbeelden leren over dit trefwoord in Java, hoe en waar ze te gebruiken.

dit zoekwoord

In Java wordt dit sleutelwoord gebruikt om te verwijzen naar het huidige object in een methode of een constructor. Bijvoorbeeld,

class Main {
    int instVar;

    Main(int instVar){
        this.instVar = instVar;
        System.out.println("this reference = " + this);
    }

    public static void main(String[] args) {
        Main obj = new Main(8);
        System.out.println("object reference = " + obj);
    }
}

Uitvoer :

this reference = Main@23fc625e
object reference = Main@23fc625e

In het bovenstaande voorbeeld hebben we een object gemaakt met de naam obj van de klasse Hoofd . We printen dan de verwijzing naar het object obj en this trefwoord van de klas.

Hier kunnen we zien dat de referentie van beide obj en this is hetzelfde. Het betekent dat dit niets anders is dan de verwijzing naar het huidige object.

Gebruik van dit zoekwoord

Er zijn verschillende situaties waarin this zoekwoord wordt vaak gebruikt.

Dit gebruiken voor namen van ambiguïteitsvariabelen

In Java is het niet toegestaan ​​om twee of meer variabelen met dezelfde naam binnen een bereik (klassebereik of methodebereik) te declareren. Instantievariabelen en parameters kunnen echter dezelfde naam hebben. Bijvoorbeeld,

class MyClass {
    // instance variable
    int age;

    // parameter
    MyClass(int age){
        age = age;
    }
}

In het bovenstaande programma hebben de instantievariabele en de parameter dezelfde naam:age. Hier is de Java-compiler in de war vanwege de ambiguïteit van de naam.

In een dergelijke situatie gebruiken we dit trefwoord. Bijvoorbeeld,

Laten we eerst een voorbeeld bekijken zonder this . te gebruiken zoekwoord:

class Main {

    int age;
    Main(int age){
        age = age;
    }

    public static void main(String[] args) {
        Main obj = new Main(8);
        System.out.println("obj.age = " + obj.age);
    }
}

Uitvoer :

obj.age = 0

In het bovenstaande voorbeeld zijn we geslaagd voor 8 als waarde voor de constructeur. We krijgen echter 0 als uitgang. Dit komt omdat de Java-compiler in de war raakt vanwege de dubbelzinnigheid in namen tussen bijvoorbeeld de variabele en de parameter.

Laten we nu de bovenstaande code herschrijven met this zoekwoord.

class Main {

    int age;
    Main(int age){
        this.age = age;
    }

    public static void main(String[] args) {
        Main obj = new Main(8);
        System.out.println("obj.age = " + obj.age);
    }
}

Uitvoer :

obj.age = 8

Nu krijgen we de verwachte output. Het is omdat wanneer de constructor wordt aangeroepen, this binnen de constructor wordt vervangen door het object obj die de constructor heeft gebeld. Vandaar de leeftijd variabele krijgt waarde 8 .

Als de naam van de parameter en instantievariabele anders is, voegt de compiler dit sleutelwoord automatisch toe. Bijvoorbeeld de code:

class Main {
    int age;

    Main(int i) {
        age = i;
    }
}

is gelijk aan:

class Main {
    int age;

    Main(int i) {
        this.age = i;
    }
}

dit met Getters en Setters

Een ander veelgebruikt gebruik van this trefwoord is in setters en getters-methoden van een klas. Bijvoorbeeld:

class Main {
   String name;

   // setter method
   void setName( String name ) {
       this.name = name;
   }

   // getter method
   String getName(){
       return this.name;
   }

   public static void main( String[] args ) {
       Main obj = new Main();

       // calling the setter and the getter method
       obj.setName("Toshiba");
       System.out.println("obj.name: "+obj.getName());
   }
}

Uitvoer :

obj.name: Toshiba

Hier hebben we this . gebruikt zoekwoord:

• om waarde toe te kennen binnen de setter-methode
• om toegang te krijgen tot waarde binnen de getter-methode

Dit gebruiken bij Constructor Overloading

Tijdens het werken met constructoroverbelasting, moeten we mogelijk een constructor van een andere constructor aanroepen. In een dergelijk geval kunnen we de constructor niet expliciet aanroepen. In plaats daarvan moeten we this . gebruiken zoekwoord.

Hier gebruiken we een andere vorm van dit trefwoord. Dat wil zeggen, this() . Laten we een voorbeeld nemen,

class Complex {

    private int a, b;

    // constructor with 2 parameters
    private Complex( int i, int j ){
        this.a = i;
        this.b = j;
    }

    // constructor with single parameter
    private Complex(int i){
        // invokes the constructor with 2 parameters
        this(i, i); 
    }

    // constructor with no parameter
    private Complex(){
        // invokes the constructor with single parameter
        this(0);
    }

    @Override
    public String toString(){
        return this.a + " + " + this.b + "i";
    }

    public static void main( String[] args ) {
  
        // creating object of Complex class
        // calls the constructor with 2 parameters
        Complex c1 = new Complex(2, 3); 
    
        // calls the constructor with a single parameter
        Complex c2 = new Complex(3);

        // calls the constructor with no parameters
        Complex c3 = new Complex();

        // print objects
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
    }
}

Uitvoer :

2 + 3i
3 + 3i
0 + 0i

In het bovenstaande voorbeeld hebben we this . gebruikt zoekwoord,

• om de constructor Complex(int i, int j) aan te roepen van de constructor Complex(int i)
• om de constructor Complex(int i) aan te roepen van de constructor Complex()

Let op de lijn,

System.out.println(c1);

Hier, wanneer we het object c1 . afdrukken , wordt het object omgezet in een string. In dit proces wordt de toString() wordt genoemd. Aangezien we de toString() . overschrijven methode binnen onze klasse, krijgen we de uitvoer volgens die methode.

Een van de enorme voordelen van this() is om de hoeveelheid dubbele code te verminderen. We moeten echter altijd voorzichtig zijn bij het gebruik van this() .

Dit komt omdat het aanroepen van een constructor van een andere constructor overhead toevoegt en het is een langzaam proces. Nog een groot voordeel van het gebruik van this() is om de hoeveelheid dubbele code te verminderen.

Opmerking :Het aanroepen van een constructor vanuit een andere constructor wordt expliciete constructoraanroep genoemd.

Dit doorgeven als argument

We kunnen this . gebruiken sleutelwoord om het huidige object als argument door te geven aan een methode. Bijvoorbeeld,

class ThisExample {
    // declare variables
    int x;
    int y;

    ThisExample(int x, int y) {
       // assign values of variables inside constructor
        this.x = x;
        this.y = y;

        // value of x and y before calling add()
        System.out.println("Before passing this to addTwo() method:");
        System.out.println("x = " + this.x + ", y = " + this.y);

        // call the add() method passing this as argument
        add(this);

        // value of x and y after calling add()
        System.out.println("After passing this to addTwo() method:");
        System.out.println("x = " + this.x + ", y = " + this.y);
    }

    void add(ThisExample o){
        o.x += 2;
        o.y += 2;
    }
}

class Main {
    public static void main( String[] args ) {
        ThisExample obj = new ThisExample(1, -2);
    }
}

Uitvoer :

Before passing this to addTwo() method:
x = 1, y = -2
After passing this to addTwo() method:
x = 3, y = 0

In het bovenstaande voorbeeld, binnen de constructor ThisExample() , let op de lijn,

add(this);

Hier noemen we de add() methode door dit als argument door te geven. Aangezien dit sleutelwoord de verwijzing bevat naar het object obj van de klasse, kunnen we de waarde van x . wijzigen en y binnen de add() methode.