Was bedeutet "dies" in Java?

Normalerweise verwende ich thisnur in Konstruktoren.

Ich verstehe, dass es verwendet wird, um die Parametervariable (mithilfe von this.something) zu identifizieren , wenn sie denselben Namen wie eine globale Variable hat.

Ich weiß jedoch nicht, was die wahre Bedeutung von thisJava ist und was passieren wird, wenn ich thisohne dot ( .) verwende.

this bezieht sich auf das aktuelle Objekt.

Jede nicht statische Methode wird im Kontext eines Objekts ausgeführt. Wenn Sie also eine Klasse wie diese haben:

public class MyThisTest {
  private int a;

  public MyThisTest() {
    this(42); // calls the other constructor
  }

  public MyThisTest(int a) {
    this.a = a; // assigns the value of the parameter a to the field of the same name
  }

  public void frobnicate() {
    int a = 1;

    System.out.println(a); // refers to the local variable a
    System.out.println(this.a); // refers to the field a
    System.out.println(this); // refers to this entire object
  }

  public String toString() {
    return "MyThisTest a=" + a; // refers to the field a
  }
}

Dann ruft frobnicate()auf new MyThisTest()druckt

1
42
MyThisTest a = 42

So effektiv nutzen Sie es für mehrere Dinge:

• Stellen Sie klar, dass es sich um ein Feld handelt, wenn es noch etwas anderes mit demselben Namen wie ein Feld gibt
• beziehen sich auf das aktuelle Objekt als Ganzes
• Rufen Sie andere Konstruktoren der aktuellen Klasse in Ihrem Konstruktor auf

Das Folgende ist ein Copy & Paste von hier , erklärt aber sehr gut alle verschiedenen Verwendungen des thisSchlüsselworts:

Definition: Das thisSchlüsselwort Java wird verwendet, um auf die aktuelle Instanz der Methode zu verweisen, für die es verwendet wird.

Es gibt folgende Möglichkeiten, dies zu verwenden:

1. Um speziell anzuzeigen, dass die Instanzvariable anstelle einer statischen oder lokalen Variablen verwendet wird. Das ist,

   private String javaFAQ;
   void methodName(String javaFAQ) {
       this.javaFAQ = javaFAQ;
   }

   Hier bezieht sich dies auf die Instanzvariable. Hier ist die Priorität für die lokale Variable hoch. Daher bezeichnet das Fehlen von thisdie lokale Variable. Wenn die lokale Variable, bei der es sich um den Namen des Parameters handelt, nicht mit der Instanzvariablen identisch thisist, wird die Instanzvariable unabhängig davon verwendet oder nicht.

2. This wird verwendet, um die Konstruktoren zu verweisen

    public JavaQuestions(String javapapers) {
        this(javapapers, true);
    }

   Dies ruft den Konstruktor derselben Java-Klasse auf, die zwei Parameter hat.

3. This wird verwendet, um die aktuelle Java-Instanz als Parameter zu übergeben

   obj.itIsMe(this);

4. Ähnlich wie oben kann dies auch verwendet werden, um die aktuelle Instanz zurückzugeben

   CurrentClassName startMethod() {
        return this;
   }

   Hinweis: Dies kann zu unerwünschten Ergebnissen führen, wenn es in inneren Klassen in den beiden oben genannten Punkten verwendet wird. Da dies auf die innere Klasse und nicht auf die äußere Instanz verweist.

5. This kann verwendet werden, um das Handle der aktuellen Klasse abzurufen

   Class className = this.getClass(); // this methodology is preferable in java

   Dies kann jedoch von getan werden

   Class className = ABC.class; // here ABC refers to the class name and you need to know that!

Wie immer thisist es mit seiner Instanz verknüpft und dies funktioniert bei statischen Methoden nicht.

Um vollständig zu sein, thiskann auch verwendet werden, um auf das äußere Objekt zu verweisen

class Outer {
    class Inner {
        void foo() {
            Outer o = Outer.this;
    }
  }
}

Es bezieht sich auf die aktuelle Instanz eines bestimmten Objekts, sodass Sie so etwas wie schreiben können

public Object getMe() {
    return this;
}

Ein häufiger Anwendungsfall thisist das Verhindern von Schatten. Nehmen Sie das folgende Beispiel:

public class Person {
    private final String name;

    public Person(String name) {
        // how would we initialize the field using parameter?
        // we can't do: name = name;
    }
}

Im obigen Beispiel möchten wir das Feldelement anhand des Parameterwerts zuweisen. Da sie denselben Namen haben, müssen wir zwischen dem Feld und dem Parameter unterscheiden können. thisermöglicht uns den Zugriff auf Mitglieder dieser Instanz, einschließlich des Feldes.

public class Person {
    private final String name;

    public Person(String name) {
        this.name = name;
    }
}

In Swing ist es ziemlich üblich, eine Klasse zu schreiben, ActionListenerdie die aktuelle Instanz (dh 'this') als ActionListener für Komponenten implementiert und hinzufügt.

public class MyDialog extends JDialog implements ActionListener
{
    public MyDialog()
    {
        JButton myButton = new JButton("Hello");
        myButton.addActionListener(this);
    }

    public void actionPerformed(ActionEvent evt)
    {
        System.out.println("Hurdy Gurdy!");
    }

}

Es ist effektiv "ein Verweis auf das Objekt im aktuellen Kontext". Um beispielsweise "dieses Objekt" auszudrucken, könnten Sie schreiben:

System.out.println(this);

Beachten Sie, dass Ihre Verwendung von "globaler Variable" etwas abweicht. Wenn Sie diese verwenden, handelt es sich this.variableNameper Definition nicht um eine globale Variable, sondern um eine für diese bestimmte Instanz spezifische Variable.

Zitieren eines Artikels unter Programming.guide:

thishat zwei Verwendungszwecke in einem Java-Programm.

1. Als Referenz auf das aktuelle Objekt

Die Syntax sieht in diesem Fall normalerweise ungefähr so ​​aus

this.someVariable = someVariable;

Diese Art der Verwendung wird hier beschrieben: Die 'this'-Referenz (mit Beispielen)

2. Einen anderen Konstruktor aufrufen

Die Syntax sieht in diesem Fall normalerweise ungefähr so ​​aus

MyClass() {
    this(DEFAULT_VALUE); // delegate to other constructor
}

MyClass(int value) {
    // ...
}

Diese Art der Verwendung wird hier beschrieben: dieser (…) Konstruktoraufruf (mit Beispielen)

Es bezieht sich auf die Instanz, in der die Methode aufgerufen wird

class A {

  public boolean is(Object o) {
    return o == this;
  }

}

A someA = new A();
A anotherA = new A();
someA.is(someA); // returns true
someA.is(anotherA); // returns false

Das Schlüsselwort this wird verwendet, um auf die aktuelle Variable eines Blocks zu verweisen. Betrachten Sie beispielsweise den folgenden Code (nur ein Beispiel, erwarten Sie also nicht den Standard-JAVA-Code):

Public class test{

test(int a) {
this.a=a;
}

Void print(){
System.out.println(a);
}

   Public static void main(String args[]){
    test s=new test(2);
    s.print();
 }
}

Das ist es. Die Ausgabe ist "2". Wenn wir das Schlüsselwort this nicht verwendet haben, lautet die Ausgabe: 0

Objekte haben Methoden und Attribute (Variablen), die von Klassen abgeleitet sind, um anzugeben, welche Methoden und Variablen zu einem bestimmten Objekt gehören, für das das thisreservierte Wort verwendet wird. Bei Instanzvariablen ist es wichtig, den Unterschied zwischen impliziten und expliziten Parametern zu verstehen. Schauen Sie sich den fillTankAufruf für das audiObjekt an.

Car audi= new Car();

audi.fillTank(5); // 5 is the explicit parameter and the car object is the implicit parameter 

Der Wert in der Klammer ist der implizite Parameter und das Objekt selbst ist der explizite Parameter. Methoden, die keine expliziten Parameter haben, verwenden implizite Parameter. Die fillTankMethode hat sowohl einen expliziten als auch einen impliziten Parameter.

Schauen wir uns die fillTankMethode in der CarKlasse genauer an

public class Car()
{
   private double tank;

   public Car()
   {
      tank = 0;
   }

   public void fillTank(double gallons)
   {
      tank = tank + gallons;
   }

}

In dieser Klasse haben wir eine Instanzvariable "tank". Es kann viele Objekte geben, die die Tankinstanzvariable verwenden. Um anzugeben, dass die Instanzvariable "tank" für ein bestimmtes Objekt verwendet wird, verwenden wir in unserem Fall das zuvor erstellte "audi" -Objekt das thisreservierte Schlüsselwort. Für Instanzvariablen gibt die Verwendung von 'this' in einer Methode an, dass die Instanzvariable, in unserem Fall "tank", eine Instanzvariable des impliziten Parameters ist.

Der Java-Compiler fügt das thisreservierte Wort automatisch hinzu , sodass Sie es nicht hinzufügen müssen. Dies ist eine Frage der Präferenz. Sie können nicht thisohne Punkt (.) Verwenden, da dies die Regeln von Java (die Syntax) sind.

Zusammenfassend.

• Objekte werden durch Klassen definiert und verfügen über Methoden und Variablen
• Die Verwendung thiseiner Instanzvariablen in einer Methode gibt an, dass die Instanzvariable zum impliziten Parameter gehört oder dass es sich um eine Instanzvariable des impliziten Parameters handelt.
• Der implizite Parameter ist das Objekt, von dem aus die Methode aufgerufen wird, in diesem Fall "audi".
• Der Java-Compiler fügt dieses reservierte Wort automatisch hinzu. Das Hinzufügen ist eine Frage der Präferenz
• this kann nicht ohne Punkt (.) verwendet werden. Dies ist syntaktisch ungültig
• this kann auch verwendet werden, um zwischen lokalen Variablen und globalen Variablen mit demselben Namen zu unterscheiden
• Das thisReservewort gilt auch für Methoden, um anzuzeigen, dass eine Methode zu einem bestimmten Objekt gehört.

Instanzvariablen sind allen von Ihnen erstellten Objekten gemeinsam. Angenommen, es gibt zwei Instanzvariablen

class ExpThisKeyWord{
int x;
int y;

public void setMyInstanceValues(int a, int b) {
    x= a;
    y=b;

    System.out.println("x is ="+x);
    System.out.println("y is ="+y);
}

}




class Demo{
public static void main(String[] args){

ExpThisKeyWord obj1 = new ExpThisKeyWord();
ExpThisKeyWord obj2 = new ExpThisKeyWord();
ExpThisKeyWord obj3 = new ExpThisKeyWord();

obj1.setMyInstanceValues(1, 2);
obj2.setMyInstanceValues(11, 22);
obj3.setMyInstanceValues(111, 222);



}
}

Wenn Sie den obigen Code bemerkt haben, haben wir drei Objekte initiiert und drei Objekte rufen die SetMyInstanceValues-Methode auf. Wie denken Sie, weist JVM die Werte für jedes Objekt korrekt zu? Es gibt den Trick, JVM wird diesen Code nicht so sehen, wie er oben gezeigt wird. Stattdessen wird der folgende Code angezeigt.

public void setMyInstanceValues(int a, int b) {
    this.x= a; //Answer: this keyword denotes the current object that is handled by JVM.
    this.y=b;

    System.out.println("x is ="+x);
    System.out.println("y is ="+y);
}

(Ich weiß, ich bin spät dran, aber ich bin der hinterhältige Boi, den du mich nie gesehen hast.)

Das Schlüsselwort this in den meisten objektorientierten Programmiersprachen bedeutet, wenn nicht alle, dass es sich um eine Referenz auf die aktuelle Objektinstanz dieser Klasse handelt. Es ist im Wesentlichen dasselbe wie das Aufrufen dieses Objekts von außerhalb der Methode mit Namen. Das ergab wahrscheinlich keinen Sinn.

Außerhalb der Klasse haben Sie beispielsweise ein Objekt namens object und möchten ein Feld abrufen, das Sie verwenden müssen, um etwas innerhalb dieser Instanz des Objekts aufzurufen

object.field

Angenommen, Sie versuchen, innerhalb Ihrer Klasse auf object.field zuzugreifen , beispielsweise auf Ihren Konstruktor, den Sie verwenden könnten

this.field

Das Schlüsselwort this ersetzt im Wesentlichen das Schlüsselwort object name, wenn es innerhalb der Klasse aufgerufen wird. Es gibt normalerweise keinen Grund, dies außerhalb zu tun, wenn Sie zwei gleichnamige Variablen haben, von denen eine ein Feld der Klasse und die andere nur eine Variable innerhalb einer Methode ist. Dies hilft bei der Entschlüsselung zwischen den beiden . Zum Beispiel, wenn Sie dies haben: (Hah, verstanden? Das ? Hehe ... nur ich? Okay :( Ich werde jetzt gehen)

public String Name;
//Constructor for {object} class
public object(String Name){
    Name = Name;
}

Dies würde einige Probleme verursachen. Der Compiler könnte den Unterschied zwischen der in den Parametern für den Konstruktor definierten Namensvariablen und der Namensvariablen in den Felddeklarationen Ihrer Klasse nicht erkennen, sodass er stattdessen den Parameter Name zuweisen würde. .. der Wert des Parameters Name, der nichts Nützliches bewirkt und buchstäblich keinen Zweck hat. Dies ist ein häufiges Problem, das die meisten neueren Programme haben, und ich war auch ein Opfer davon. Der richtige Weg, um diesen Parameter zu definieren, wäre:

public String Name;
//Constructor for {object} class
public object(String Name){
    this.Name = Name;
}

Auf diese Weise weiß der Compiler, dass die Name-Variable, die Sie zuweisen möchten, Teil der Klasse und nicht Teil der Methode ist, und weist sie korrekt zu. Dies bedeutet, dass das Feld Name dem zugewiesen wird, was Sie in den Konstruktor eingeben.

Zusammenfassend verweist es im Wesentlichen auf ein Feld der Objektinstanz der Klasse, an der Sie arbeiten. Daher ist es das Schlüsselwort "this", was bedeutet, dass es sich um dieses Objekt oder diese Instanz handelt. Es ist eine gute Praxis, dies zu verwenden, wenn Sie ein Feld Ihrer Klasse aufrufen, anstatt nur den Namen zu verwenden, um mögliche Fehler zu vermeiden, die schwer zu finden sind, da der Compiler direkt darüber läuft.

Eine schnelle Google-Suche brachte dieses Ergebnis: http://xahlee.org/java-a-day/this.html

Das Schlüsselwort "this" bezieht sich auf das aktuelle Objekt (selbst).

thisist ein Verweis auf das aktuelle Objekt: http://download.oracle.com/javase/tutorial/java/javaOO/thiskey.html

Dies kann innerhalb einer Methode oder eines Konstruktors verwendet werden.

Es gibt den Verweis auf das aktuelle Objekt zurück.

Dies bezieht sich auf das Objekt, in dem Sie sich gerade befinden. Mit anderen Worten bezieht sich dies auf das empfangende Objekt. Sie verwenden dies, um zu klären, auf welche Variable Sie sich beziehen. Java_whitepaper Seite: 37

class Point extends Object
{
    public double x;
    public double y;

    Point()
    {
        x = 0.0;
        y = 0.0;
    }

    Point(double x, double y)
    {
        this.x = x;
        this.y = y;
    }
}

Im obigen Beispielcode bezieht sich this.x / this.y auf die aktuelle Klasse, dh die Variablen der Punktklasse x und y, wobei (double x, double y) Doppelwerte sind, die von verschiedenen Klassen übergeben werden, um der aktuellen Klasse Werte zuzuweisen.

Ich suchte auch nach der gleichen Antwort und konnte das Konzept irgendwie nicht klar verstehen. Aber schließlich habe ich es von diesem Link verstanden

Dies ist ein Schlüsselwort in Java. Welche kann innerhalb der Methode oder Konstruktor der Klasse verwendet werden. Es funktioniert als Referenz auf ein aktuelles Objekt, dessen Methode oder Konstruktor aufgerufen wird. Mit diesem Schlüsselwort kann auf jedes Mitglied eines aktuellen Objekts innerhalb einer Instanzmethode oder eines Konstruktors verwiesen werden.

Überprüfen Sie die Beispiele im Link für ein klares Verständnis

Wenn die Instanzvariablen mit den Variablen übereinstimmen, die im Konstruktor deklariert sind, verwenden wir "this", um Daten zuzuweisen.

class Example{
     int assign;// instance variable

     Example(int assign){ // variable inside constructor
          this.assign=assign;
     }
}

Hoffe das hilft.

In Java ist "this" eine vordefinierte Variable. Wenn wir "this" in einer Methode verwenden, bedeutet dies, dass wir die Referenz (Adresse) des aktuell ausgeführten Objekts erhalten. Zum Beispiel.

this.age ---> Alter des aktuell ausgeführten Objekts.

Ich möchte mitteilen, was ich unter diesem Schlüsselwort verstanden habe. Dieses Schlüsselwort hat 6 Verwendungen in Java wie folgt: -

1. Es kann verwendet werden, um auf die aktuelle Klassenvariable zu verweisen. Lassen Sie uns mit einem Code verstehen. *

Lassen Sie uns das Problem verstehen, wenn wir dieses Schlüsselwort nicht anhand des folgenden Beispiels verwenden:

class Employee{  
int id_no;  
String name;  
float salary;  
Student(int id_no,String name,float salary){  
id_no = id_no;  
name=name;  
salary = salary;  
}  
void display(){System.out.println(id_no +" "+name+" "+ salary);}  
}  
class TestThis1{  
public static void main(String args[]){  
Employee s1=new Employee(111,"ankit",5000f);  
Employee s2=new Employee(112,"sumit",6000f);  
s1.display();  
s2.display();  
}}  

Ausgabe:-

0 null 0.0
0 null 0.0

Im obigen Beispiel sind Parameter (formale Argumente) und Instanzvariablen identisch. Daher verwenden wir dieses Schlüsselwort, um lokale Variablen und Instanzvariablen zu unterscheiden.

class Employee{  
int id_no;  
String name;  
float salary;  
Student(int id_no,String name,float salary){  
this.id_no = id_no;  
this.name=name;  
this.salary = salary;  
}  
void display(){System.out.println(id_no +" "+name+" "+ salary);}  
}  
class TestThis1{  
public static void main(String args[]){  
Employee s1=new Employee(111,"ankit",5000f);  
Employee s2=new Employee(112,"sumit",6000f);  
s1.display();  
s2.display();  
}} 

Ausgabe:

111 ankit 5000
112 sumit 6000

2. Um die aktuelle Klassenmethode aufzurufen.

class A{  
void m(){System.out.println("hello Mandy");}  
void n(){  
System.out.println("hello Natasha");  
//m();//same as this.m()  
this.m();  
}  
}  
class TestThis4{  
public static void main(String args[]){  
A a=new A();  
a.n();  
}}  

Ausgabe:

hello Natasha
hello Mandy

3. um den aktuellen Klassenkonstruktor aufzurufen. Es wird zur Konstruktorkettung verwendet.

class A{  
A(){System.out.println("hello ABCD");}  
A(int x){  
this();  
System.out.println(x);  
}  
}  
class TestThis5{  
public static void main(String args[]){  
A a=new A(10);  
}}

Ausgabe:

hello ABCD
10

4. als Argument in der Methode zu übergeben.

class S2{  
  void m(S2 obj){  
  System.out.println("The method is invoked");  
  }  
  void p(){  
  m(this);  
  }  
  public static void main(String args[]){  
  S2 s1 = new S2();  
  s1.p();  
  }  
}  

Ausgabe:

The method is invoked

5. als Argument im Konstruktoraufruf übergeben

class B{  
  A4 obj;  
  B(A4 obj){  
    this.obj=obj;  
  }  
  void display(){  
    System.out.println(obj.data);//using data member of A4 class  
  }  
}  

class A4{  
  int data=10;  
  A4(){  
   B b=new B(this);  
   b.display();  
  }  
  public static void main(String args[]){  
   A4 a=new A4();  
  }  
} 

Ausgabe:-

10

6. um die aktuelle Klasseninstanz zurückzugeben

class A{  
A getA(){  
return this;  
}  
void msg(){System.out.println("Hello");}  
}  
class Test1{  
public static void main(String args[]){  
new A().getA().msg();  
}  
}  

Ausgabe:-

Hello

Dieses Schlüsselwort kann auch nicht ohne. (Punkt) verwendet werden, da seine Syntax ungültig ist.