In dit artikel zullen we met behulp van voorbeelden leren over dit sleutelwoord in Java, hoe en waar we het kunnen gebruiken.
dit trefwoord
In Java wordt dit sleutelwoord gebruikt om te verwijzen naar het huidige object binnen een methode of 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); ) )
Uitgang :
deze referentie = Main @ 23fc625e objectreferentie = Main @ 23fc625e
In het bovenstaande voorbeeld hebben we een object gemaakt met de naam obj van de klasse Main. Vervolgens printen we de verwijzing naar het object obj en het thistrefwoord van de klasse.
Hier kunnen we zien dat de referentie van zowel obj als thishetzelfde is. Het betekent dat dit niets anders is dan de verwijzing naar het huidige object.
Gebruik van dit trefwoord
Er zijn verschillende situaties waarin thistrefwoord vaak wordt gebruikt.
Dit gebruiken voor namen van ambiguïteitvariabelen
In Java is het niet toegestaan om twee of meer variabelen met dezelfde naam te declareren binnen een scope (class scope of method scope). 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: leeftijd. Hier is de Java-compiler in de war vanwege de dubbelzinnigheid van de naam.
In zo'n situatie gebruiken we dit trefwoord. Bijvoorbeeld,
Laten we eerst een voorbeeld bekijken zonder thistrefwoord te gebruiken:
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); ) )
Uitgang :
mc.age = 0
In het bovenstaande voorbeeld hebben we 8als waarde doorgegeven aan de constructor. We krijgen echter 0als output. Dit komt doordat de Java-compiler in de war raakt vanwege de ambiguïteit in namen tussen de instantie de variabele en de parameter.
Laten we nu de bovenstaande code herschrijven met behulp van een thistrefwoord.
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); ) )
Uitgang :
obj.age = 8
Nu krijgen we de verwachte output. Het is omdat wanneer de constructor wordt aangeroepen, thisbinnen de constructor wordt vervangen door het object obj dat de constructor heeft aangeroepen. Daarom krijgt de leeftijdsvariabele de waarde 8 toegewezen.
Als de naam van de parameter en de 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 thistrefwoord is in setters en getters-methoden van een klasse. 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()); ) )
Uitgang :
obj.name: Toshiba
Hier hebben we thistrefwoord gebruikt :
- om waarde toe te wijzen binnen de setter-methode
- om toegang te krijgen tot waarde binnen de getter-methode
Gebruik dit in Constructor Overloading
Tijdens het werken met overbelasting van de constructor, moeten we mogelijk een constructor aanroepen vanuit een andere constructor. In dat geval kunnen we de constructor niet expliciet aanroepen. In plaats daarvan moeten we thistrefwoord gebruiken.
Hier gebruiken we een andere vorm van dit trefwoord. Dat is 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); ) )
Uitgang :
2 + 3i 3 + 3i 0 + 0i
In het bovenstaande voorbeeld hebben we thistrefwoord gebruikt ,
- om de constructor aan te roepen
Complex(int i, int j)vanuit de constructorComplex(int i) - om de constructor aan te roepen
Complex(int i)vanuit de constructorComplex()
Let op de lijn,
System.out.println(c1);
Here, when we print the object c1, the object is converted into a string. In this process, the toString() is called. Since we override the toString() method inside our class, we get the output according to that method.
One of the huge advantages of this() is to reduce the amount of duplicate code. However, we should be always careful while using this().
This is because calling constructor from another constructor adds overhead and it is a slow process. Another huge advantage of using this() is to reduce the amount of duplicate code.
Note: Invoking one constructor from another constructor is called explicit constructor invocation.
Passing this as an Argument
We can use this keyword to pass the current object as an argument to a method. For example,
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); ) )
Uitgang :
Voordat u dit doorgeeft aan de methode addTwo (): x = 1, y = -2 Nadat u dit doorgeeft aan de methode addTwo (): x = 3, y = 0
Let in het bovenstaande voorbeeld in de constructor ThisExample()op de regel,
add(this);
Hier noemen we de add()methode door dit als argument door te geven. Omdat dit sleutelwoord de verwijzing naar het object obj van de klasse bevat, kunnen we de waarde van x en y binnen de add()methode wijzigen.
