In diesem Artikel erfahren Sie anhand von Beispielen, wie und wo Sie dieses Schlüsselwort in Java verwenden können.
dieses Schlüsselwort
In Java wird dieses Schlüsselwort verwendet, um auf das aktuelle Objekt innerhalb einer Methode oder eines Konstruktors zu verweisen. Beispielsweise,
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); ) )
Ausgabe :
Diese Referenz = Main @ 23fc625e Objektreferenz = Main @ 23fc625e
Im obigen Beispiel haben wir ein Objekt mit dem Namen obj der Klasse Main erstellt. Wir drucken dann den Verweis auf das Objekt obj und das thisSchlüsselwort der Klasse.
Hier können wir sehen, dass die Referenz von obj und thisgleich ist. Dies bedeutet, dass dies nichts anderes als der Verweis auf das aktuelle Objekt ist.
Verwendung dieses Schlüsselworts
Es gibt verschiedene Situationen, in denen häufig thisSchlüsselwörter verwendet werden.
Verwenden Sie diese Option für Ambiguity-Variablennamen
In Java ist es nicht zulässig, zwei oder mehr Variablen mit demselben Namen innerhalb eines Bereichs (Klassenbereich oder Methodenbereich) zu deklarieren. Instanzvariablen und -parameter können jedoch denselben Namen haben. Beispielsweise,
class MyClass ( // instance variable int age; // parameter MyClass(int age)( age = age; ) )
Im obigen Programm haben die Instanzvariable und der Parameter denselben Namen: age. Hier ist der Java-Compiler aufgrund von Namensmehrdeutigkeiten verwirrt.
In einer solchen Situation verwenden wir dieses Schlüsselwort. Beispielsweise,
Schauen wir uns zunächst ein Beispiel ohne thisSchlüsselwort an:
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); ) )
Ausgabe :
mc.age = 0
Im obigen Beispiel haben wir 8einen Wert an den Konstruktor übergeben. Wir bekommen jedoch 0als Ausgabe. Dies liegt daran, dass der Java-Compiler aufgrund der Mehrdeutigkeit der Namen zwischen der Instanz der Variablen und dem Parameter verwirrt wird.
Schreiben wir nun den obigen Code mit dem thisSchlüsselwort neu.
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); ) )
Ausgabe :
obj.age = 8
Jetzt erhalten wir die erwartete Ausgabe. Es liegt daran , dass , wenn der Konstruktor aufgerufen wird , thisinnerhalb der Konstruktor durch das Objekt obj ersetzt wird, der Konstruktor aufgerufen hat. Daher wird der Altersvariablen der Wert 8 zugewiesen.
Wenn der Name des Parameters und der Instanzvariablen unterschiedlich ist, hängt der Compiler dieses Schlüsselwort automatisch an. Zum Beispiel der Code:
class Main ( int age; Main(int i) ( age = i; ) )
ist äquivalent zu:
class Main ( int age; Main(int i) ( this.age = i; ) )
dies mit Getters und Setter
Eine andere häufige Verwendung von thisSchlüsselwörtern sind Setter- und Getter-Methoden einer Klasse. Beispielsweise:
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()); ) )
Ausgabe :
Objektname: Toshiba
Hier haben wir das thisSchlüsselwort verwendet:
- Wert innerhalb der Setter-Methode zuweisen
- um auf den Wert innerhalb der Getter-Methode zuzugreifen
Verwenden Sie diese Option beim Überladen von Konstruktoren
Während der Arbeit mit Konstruktorüberladung müssen wir möglicherweise einen Konstruktor von einem anderen Konstruktor aufrufen. In einem solchen Fall können wir den Konstruktor nicht explizit aufrufen. Stattdessen müssen wir ein thisSchlüsselwort verwenden.
Hier verwenden wir eine andere Form dieses Schlüsselworts. Das heißt , this(). Nehmen wir ein Beispiel,
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); ) )
Ausgabe :
2 + 3i 3 + 3i 0 + 0i
Im obigen Beispiel haben wir das thisSchlüsselwort verwendet:
- den Konstruktor
Complex(int i, int j)vom Konstruktor aus aufrufenComplex(int i) - den Konstruktor
Complex(int i)vom Konstruktor aus aufrufenComplex()
Beachten Sie die Linie,
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); ) )
Ausgabe :
Bevor Sie dies an die addTwo () -Methode übergeben: x = 1, y = -2 Nach dem Übergeben an die addTwo () -Methode: x = 3, y = 0
Beachten Sie im obigen Beispiel im Konstruktor ThisExample()die Zeile:
add(this);
Hier rufen wir die add()Methode auf, indem wir dies als Argument übergeben. Da dieses Schlüsselwort den Verweis auf das Objekt obj der Klasse enthält, können wir den Wert von x und y innerhalb der add()Methode ändern .
