Java-this-Schlüsselwort

In diesem Artikel werden wir durch Beispiele lernen, wie der this-Schlüsselwort in Java verwendet wird, wann und wo sie verwendet werden.

this-Schlüsselwort

Der this-Schlüsselwort in Java wird verwendet, um auf das aktuelle Objekt in Methoden oder Konstruktoren zu verweisen. Zum Beispiel,

class Main {
　　　　int instVar;
　　　　Main(int instVar){
　　　　　　　　this.instVar = instVar;
　　　　　　　　System.out.println("this-Referenz= ");　+　this);
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　Main obj = new Main(8);
　　　　　　　　System.out.println("Objekt-Referenz= ");　+　obj);
　　　　}
}

Ausgabe:

this-Referenz = com.ThisAndThat.MyClass@74a14482
Objekt-Referenz = com.ThisAndThat.MyClass@74a14482

Im obigen Beispiel haben wir ein Objekt namens obj der Klasse Main erstellt. Dann haben wir die Referenzen auf das Objekt der Klasse obj und den this-Schlüsselwort gedruckt.

Hier können wir sehen, dass die Referenzen von obj und this identisch sind. Dies bedeutet, dass dies nur eine Referenz auf das aktuelle Objekt ist.

Verwenden Sie den this-Schlüsselwort

In verschiedenen Fällen wird normalerweise der this-Schlüsselwort verwendet.

Verwenden Sie this, um die Mehrdeutigkeit von Variablennamen zu behandeln

In Java ist es nicht erlaubt, zwei oder mehrere Variablen mit demselben Namen in einem Bereich (Klassenbereich oder Methodenbereich) zu deklarieren. Allerdings können Instanzvariablen und Parameter denselben Namen haben. Zum Beispiel,

class MyClass {
　　　　//　Instanzvariable
　　　　int age;
　　　　//　Parameter
　　　　MyClass(int age){
　　　　　　　　age = age;
　　　　}
}

Im obigen Programm haben die Instanzvariablen und die Parameter denselben Namen: age. Hier ist der Java-Compiler aufgrund der unklaren Namensgebung verwirrt.

In diesem Fall verwenden wir den this-Schlüsselwort. Zum Beispiel,

Lassen Sie uns zunächst ein Beispiel betrachten, bei dem der this-Schlüsselwort nicht verwendet wird:

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

In diesem Beispiel haben wir einen Wert8Wird dem Konstruktor übergeben. Aber, das 0, das wir erhalten, ist die Ausgabe. Dies liegt daran, dass der Java-Compiler aufgrund der unklaren Namensgebung zwischen Instanzvariablen und Parametern verwirrt ist.

Lassen Sie uns nun den obigen Code mit dem this-Schlüsselwort neu schreiben.

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 haben wir die erwartete Ausgabe. Dies liegt daran, dass der Inhalt des Konstruktors ersetzt wird, wenn der Konstruktor aufgerufen wird, durch das Objekt, das den Konstruktor aufruft. Daher wird die Variable age zugewiesen mit8.

Außerdem fügt der Compiler automatisch das this-Schlüsselwort hinzu, wenn der Name des Parameters und der des Instanzvariablen unterschiedlich ist. Zum Beispiel:

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

entspricht:

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

this und Getters und Setters

Eine weitere häufige Verwendung des this-Schlüsselworts ist in derSetter- und Getter-Methodenz.B.:

class Main {
　　　String name;
　　　//　Setter-Methode
　　　void setName(String name) {
　　　　　　　this.name = name;
　　　}
　　　//　Getter-Methode
　　　String getName(){
　　　　　　　return this.name;
　　　}
　　　public static void main(String[] args) {
　　　　　　　Main obj = new Main();
　　　　　　　//　Aufruf von Setter- und Getter-Methoden
　　　　　　　obj.setName("Seagull");
　　　　　　　System.out.println("obj.name: ",+obj.getName());
　　　}
}

Ausgabe:

obj.name: Seagull

Hier haben wir das this-Schlüsselwort verwendet:

• Werte im Setter-Methoden zuweisen

• Werte im Getter-Methoden aufrufen

bei der Verwendung von this in der Konstruktor-Überschreibung

bei der Verarbeitungbei der Konstruktor-ÜberschreibungMöglicherweise müssen wir aus einem anderen Konstruktor einen Konstruktor aufrufen. In diesem Fall können wir den Konstruktor nicht explizit aufrufen. Stattdessen müssen wir das this-Schlüsselwort verwenden.

Hier verwenden wir eine andere Form des this-Schlüsselworts. Namlich this(). Lassen Sie uns ein Beispiel nennen

class Complex {
　　　　private int a, b;
　　　　//Konstruktor mit zwei Parametern
　　　　private Complex(int i, int j) {
　　　　　　　　this.a = i;
　　　　　　　　this.b = j;
　　　　}
　　　　//Konstruktor mit einem Parameter
　　　　private Complex(int i){
　　　　　　　　//Mit zwei Parametern den Konstruktor aufrufen
　　　　　　　　this(i, i);　
　　　　}
　　　　//Konstruktor ohne Parameter
　　　　private Complex(){
　　　　　　　　//Mit einem Parameter den Konstruktor aufrufen
　　　　　　　　this(0);
　　　　}
　　　　@Override
　　　　public String toString(){
　　　　　　　　return this.a　+　"　+　"　+　this.b　+　"i";
　　　　}
　　　　public static void main(String[] args) {
　　
　　　　　　　　　　　　　　　　//Erstellen Sie ein Objekt der Klasse Complex
　　　　　　　　　　　　　　　　//Verwenden2Mit Parameter aufrufen den Konstruktor　
　　　　　　　　Complex c1　= new Complex(2,　3);　
　　　　
　　　　　　　　//Mit einem Parameter den Konstruktor aufrufen
　　　　　　　　Complex c2　= new Complex(3);
　　　　　　　　//Ohne Parameter den Konstruktor aufrufen
　　　　　　　　Complex c3　= new Complex();
　　　　　　　　//Druck des Objekts
　　　　　　　　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 Schlüsselwort this verwendet,

• Aufruf des Konstruktors Complex(inti) aus dem Konstruktor Complex(inti, intj)

• Aufruf des Konstruktors Complex() aus dem Konstruktor Complex(int i)

Hinweis auf diese Zeile,

System.out.println(c1);

Hier, wenn wir das Objekt c drucken1Wenn, im Prozess der Konvertierung eines Objekts in einen String. Während dieses Prozesses wird toString() aufgerufen. Da wir die Methode toString() in der Klasse überschrieben haben, erhalten wir den Ausgabe nach dieser Methode.

　Einer der größten Vorteile von this() ist die Verringerung der Anzahl der wiederholten Codes. Aber, wenn wir this() verwenden, sollten wir besonders vorsichtig sein.

　Dies ist, weil der Aufruf eines Konstruktors von einem anderen Konstruktor zusätzliche Kosten verursacht und ein langsamer Prozess ist. Ein weiterer großer Vorteil der Verwendung von this() ist die Verringerung der Anzahl der wiederholten Codes.

Hinweis：Eine Konstruktoraufruf von einem anderen Konstruktor wird als expliziter Konstruktoraufruf bezeichnet.

this als Parameter übergeben

Wir können den Schlüsselwort this verwenden, um das aktuelle Objekt als Parameter an eine Methode zu übergeben. Zum Beispiel,

class ThisExample {
　　　　//　Variablen deklarieren
　　　　int x;
　　　　int y;
　　　　ThisExample(int x, int y) {
　　　　　　　　　　//Zuweisung von Variablen im Konstruktor
　　　　　　　　this.x = x;
　　　　　　　　this.y = y;
　　　　　　　　//Werte von x und y vor dem Aufruf von add()
　　　　　　　　System.out.println("Vor dem Übertragen von this an die Methode addTwo():");
　　　　　　　　System.out.println("x = ")}　+　this.x　+　", y = ",　+　this.y);
　　　　　　　　//Aufruf der Methode add(), Übertragung von this als Parameter
　　　　　　　　add(this);
　　　　　　　　//Werte von x und y nach dem Aufruf von add()
　　　　　　　　System.out.println("Nach der Übertragung von this an die Methode addTwo():");
　　　　　　　　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 wir this an die Methode addTwo() übergeben:
x =　1, y =　-2
Nachdem wir this an die Methode addTwo() übergeben haben:
x =　3, y = 0

In dem obigen Beispiel beachten Sie die folgende Zeile in der Konstruktor ThisExample()

add(this);

Hier rufen wir die add() Methode auf, indem wir this als Parameter übergeben. Da der this-Schlüssel eine Referenz auf das Objekt obj der Klasse enthält, können wir den Wert von x und y in der add() Methode ändern.