Java dieses Schlüsselwort
Java dieses Schlüsselwort
In diesem Artikel erfahren wir anhand von Beispielen mehr über dieses Schlüsselwort in Java, wie und wo man es verwendet.
dieses Schlüsselwort
In Java wird dieses Schlüsselwort verwendet, um auf das aktuelle Objekt innerhalb einer Methode oder eines Konstruktors zu verweisen. Zum Beispiel
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 :
this reference = Main@23fc625e object reference = Main@23fc625e
Im obigen Beispiel haben wir ein Objekt namens obj erstellt der Klasse Main . Wir geben dann die Referenz auf das Objekt obj aus und this Schlüsselwort der Klasse.
Hier können wir sehen, dass die Referenz der beiden obj und this ist dasselbe. Dies bedeutet, dass dies nichts anderes als die Referenz auf das aktuelle Objekt ist.
Verwendung dieses Keywords
Es gibt verschiedene Situationen, in denen this Schlüsselwort wird häufig verwendet.
Dies für mehrdeutige Variablennamen verwenden
In Java ist es nicht erlaubt, zwei oder mehr Variablen mit demselben Namen innerhalb eines Bereichs (Klassenbereich oder Methodenbereich) zu deklarieren. Instanzvariablen und Parameter können jedoch denselben Namen haben. Zum Beispiel
class MyClass {
// instance variable
int age;
// parameter
MyClass(int age){
age = age;
}
} Im obigen Programm haben die Instanzvariable und der Parameter denselben Namen:Alter. Hier ist der Java-Compiler aufgrund von Namensmehrdeutigkeiten verwirrt.
In einer solchen Situation verwenden wir dieses Schlüsselwort. Zum Beispiel
Sehen wir uns zuerst ein Beispiel an, ohne this zu verwenden Stichwort:
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 :
obj.age = 0
Im obigen Beispiel haben wir 8 übergeben als Wert für den Konstruktor. Wir erhalten jedoch 0 als Ausgabe. Dies liegt daran, dass der Java-Compiler aufgrund der Mehrdeutigkeit der Namen zwischen Instanz, Variable und Parameter verwirrt wird.
Lassen Sie uns nun den obigen Code mit this umschreiben Schlüsselwort.
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. Denn wenn der Konstruktor aufgerufen wird, this innerhalb des Konstruktors wird durch das Objekt obj ersetzt das hat den Konstruktor aufgerufen. Daher das Alter Variable wird der Wert 8 zugewiesen .
Wenn der Name des Parameters und der Instanzvariablen unterschiedlich sind, hängt der Compiler dieses Schlüsselwort automatisch an. Zum Beispiel der Code:
class Main {
int age;
Main(int i) {
age = i;
}
} entspricht:
class Main {
int age;
Main(int i) {
this.age = i;
}
} dies mit Gettern und Settern
Eine weitere häufige Verwendung von this Das Schlüsselwort befindet sich in Setter- und Getter-Methoden einer Klasse. Zum Beispiel:
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 :
obj.name: Toshiba
Hier haben wir this verwendet Stichwort:
- Wert innerhalb der Setter-Methode zuweisen
- auf den Wert innerhalb der Getter-Methode zugreifen
Dies beim Konstruktorüberladen verwenden
Beim Arbeiten mit dem Überladen von Konstruktoren 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 this verwenden Schlüsselwort.
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 this verwendet Schlüsselwort,
- um den Konstruktor
Complex(int i, int j)aufzurufen aus dem KonstruktorComplex(int i) - um den Konstruktor
Complex(int i)aufzurufen aus dem KonstruktorComplex()
Beachten Sie die Zeile,
System.out.println(c1);
Hier, wenn wir das Objekt c1 drucken , wird das Objekt in einen String umgewandelt. Dabei wird der toString() wird genannt. Da überschreiben wir den toString() Methode innerhalb unserer Klasse erhalten wir die Ausgabe gemäß dieser Methode.
Einer der großen Vorteile von this() ist es, die Menge an doppeltem Code zu reduzieren. Wir sollten jedoch immer vorsichtig sein, wenn wir this() verwenden .
Dies liegt daran, dass das Aufrufen des Konstruktors von einem anderen Konstruktor Overhead hinzufügt und ein langsamer Prozess ist. Ein weiterer großer Vorteil der Verwendung von this() ist es, die Menge an doppeltem Code zu reduzieren.
Hinweis :Das Aufrufen eines Konstruktors von einem anderen Konstruktor wird als expliziter Konstruktoraufruf bezeichnet.
Dies als Argument übergeben
Wir können this verwenden -Schlüsselwort, um das aktuelle Objekt als Argument an eine Methode zu übergeben. Zum Beispiel
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 :
Before passing this to addTwo() method: x = 1, y = -2 After passing this to addTwo() method: x = 3, y = 0
Im obigen Beispiel innerhalb des Konstruktors ThisExample() , beachten Sie die Zeile,
add(this);
Hier nennen wir den add() Methode, indem Sie dies als Argument übergeben. Da dieses Schlüsselwort die Referenz auf das Objekt obj enthält der Klasse können wir den Wert von x ändern und y innerhalb der add() Methode.
Java