Java中“this”是什么意思？

它指的是特定对象的当前实例，因此您可以编写类似

public Object getMe() {
    return this;
}

---

一个常见的用例是防止阴影。以以下示例为例：this

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;
    }
}

在上面的示例中，我们希望使用参数的值分配字段成员。由于它们具有相同的名称，因此我们需要一种方法来区分字段和参数。 允许我们访问此实例的成员，包括字段。this

public class Person {
    private final String name;

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

它实际上是“对当前上下文中对象的引用”。例如，要打印出“这个对象”，你可以这样写：

System.out.println(this);

请注意，您对“全局变量”的使用有些偏离......如果你使用，那么根据定义，它不是一个全局变量 - 它是特定于这个特定实例的变量。this.variableName

快速的谷歌搜索带来了这个结果： 链接

“this”关键字几乎是对当前对象（本身）的引用。

this是对当前对象的引用：http://download.oracle.com/javase/tutorial/java/javaOO/thiskey.html

这可以在一些方法或构造函数中使用。

它返回对当前对象的引用。

它是指在其上调用该方法的实例

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

this指当前对象。

每个非静态方法都在对象的上下文中运行。因此，如果您有这样的类：

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
  }
}

然后调用将打印frobnicate()new MyThisTest()

1
42
MyThisTest a=42

因此，您可以有效地将其用于多种用途：

• 澄清您正在谈论一个字段，而还有其他与字段同名的东西
• 将当前对象作为一个整体进行引用
• 在构造函数中调用当前类的其他构造函数

在 Swing 中，编写一个类来实现并添加当前实例（即“this”）作为组件的 ActionListener 是相当常见的。ActionListener

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!");
    }

}

以下是从这里复制和粘贴的内容，但很好地解释了关键字的所有不同用法：this

定义：Java 的 this 关键字用于引用使用它的方法的当前实例。

以下是使用此功能的方法：

1. 具体表示使用实例变量而不是静态或局部变量。那是

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

   这里指的是实例变量。在这里，局部变量的优先级很高。因此，缺少 表示局部变量。如果作为参数名称的局部变量与实例变量不同，则无论是否使用，它都表示实例变量。thisthis

2. this用于引用构造函数

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

   这将调用具有两个参数的同一 java 类的构造函数。

3. this用于将当前 Java 实例作为参数传递

   obj.itIsMe(this);
   

4. 与上面类似，这也可用于返回当前实例

   CurrentClassName startMethod() {
        return this;
   }
   

   注意：在上述两点的内部类中使用时，这可能会导致不希望的结果。因为这将指内部类而不是外部实例。

5. this可用于获取当前类的句柄

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

虽然这可以通过以下方式完成

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

与往常一样，与其实例相关联，这在静态方法中不起作用。this

引用 programming.guide 上的一篇文章：

---

this在 Java 程序中有两个用途。

1. 作为对当前对象的引用

在这种情况下，语法通常如下所示

this.someVariable = someVariable;

此处描述了这种类型的使用：“this”引用（带有示例）

2.调用不同的构造函数

在这种情况下，语法通常如下所示

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

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

下面描述了这种类型的用法：this（...） 构造函数调用（带示例）

要完整，也可以用来指代外在对象this

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

对象具有从类派生的方法和属性（变量），以便指定使用保留字属于特定对象的方法和变量。对于实例变量，了解隐式参数和显式参数之间的区别非常重要。看一下对对象的调用。thisfillTankaudi

Car audi= new Car();

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

括号中的值是隐式参数，对象本身是显式参数，没有显式参数的方法使用隐式参数，方法同时具有显式参数和隐式参数。fillTank

让我们仔细看看类中的方法fillTankCar

public class Car()
{
   private double tank;

   public Car()
   {
      tank = 0;
   }

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

}

在这个类中，我们有一个实例变量 “tank”。可能有许多对象使用 tank 实例变量，为了指定实例变量 “tank” 用于特定对象，在我们的例子中，我们之前构造的 “audi” 对象，我们使用 reserved 关键字。对于实例变量，在方法中使用“this”表示实例变量（在我们的例子中为“tank”）是隐式参数的实例变量。this

java 编译器会自动添加保留字，因此您不必添加它，这是一个偏好问题。你不能在没有 dot（.） 的情况下使用，因为这些是 java 的规则（语法）。thisthis

综上所述。

• 对象由类定义，并具有方法和变量
• 在方法中使用 on 实例变量表示该实例变量属于隐式参数，或者它是隐式参数的实例变量。this
• 隐式参数是从中调用方法的对象，在本例中为“audi”。
• java 编译器会自动添加 this 保留字，添加它是一个偏好问题
• this不能在没有 dot（.） 的情况下使用 这在语法上是无效的
• this还可用于区分具有相同名称的局部变量和全局变量
• 保留字也适用于方法，以指示方法属于特定对象。this

this 关键字用于引用块的当前变量，例如考虑下面的代码（只是一个示例，所以不要指望标准的 JAVA 代码）：

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();
 }
}

就是这样。输出将为“2”。 如果我们没有使用 this 关键字，那么输出将是：0

我也在寻找同样的答案，不知何故无法清楚地理解这个概念。但最后我从这个链接中明白了

这是 Java 中的一个关键字。可以在类的方法或构造函数中使用。It（this） 用作对正在调用其方法或构造函数的当前对象的引用。此关键字可用于从实例方法或构造函数中引用当前对象的任何成员。

查看链接中的示例以清楚地了解

如果实例变量与构造函数中声明的变量相同，则我们使用“this”来分配数据。

class Example{
     int assign;// instance variable

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

希望这会有所帮助。

在 Java 中，“this”是一个预定义的变量。如果我们在方法中使用“this”，这意味着我们正在获取当前正在运行的对象的引用（地址）。举个例子。

this.age --->当前正在运行的对象的期限。

实例变量对于您创建的每个对象都是通用的。比如说，有两个实例变量

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);



}
}

如果您注意到上面的代码，我们已经启动了三个对象，并且三个对象正在调用 SetMyInstanceValues 方法。 您认为 JVM 如何正确地为每个对象分配值？ 有一个诀窍，JVM不会看到上面显示的这段代码。取而代之的是，它将看到如下代码;

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);
}

（我知道我迟到了，但嘘，我是你从未见过我的鬼鬼祟祟的boi）

在大多数面向对象的编程语言中，这个关键字（如果不是全部）意味着它是对该类的当前对象实例的引用。这与按名称从方法外部调用该对象本质上是相同的。这可能没有意义，所以 Ill 详细说明：

在类之外，为了调用该对象实例中的某些内容，例如，假设您有一个名为 object 的对象，并且您想要获取需要使用的字段

object.field

例如，假设您正在尝试从类内部访问 object.field，例如，您的构造函数，您可以使用

this.field

当在类内部调用时，this 关键字实质上替换了对象名称关键字。除了有两个同名的变量之外，通常没有太多理由这样做，其中一个是类的字段，另一个只是方法内部的变量，这有助于在两者之间进行破译。例如，如果您有以下情况： （呵呵，明白了吗？这？呵呵。。。。就我自己？好的:(我现在就走）

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

这会导致一些问题，编译器将无法知道构造函数参数中定义的 Name 变量与类字段声明中的 Name 变量之间的区别，因此它会将 Name 参数分配给......Name 参数的值，它没有任何好处，实际上没有任何用途。这是大多数较新程序都会遇到的常见问题，我也是受害者。无论如何，定义此参数的正确方法是使用：

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

这样，编译器就知道您尝试分配的 Name 变量是类的一部分，而不是方法的一部分，并正确分配它，这意味着它会将 Name 字段分配给您放入构造函数中的任何内容。

总而言之，它本质上引用了您正在处理的类的对象实例的字段，因此它是关键字“this”，意思是它的 this 对象或 this 实例。在调用类的字段时使用它是一个很好的做法，而不仅仅是使用名称，以避免在编译器直接运行它们时难以发现的可能错误。

这是指您现在“处于”中的对象。换言之，这是指接收对象。您可以使用它来阐明您指的是哪个变量。Java_whitepaper页 ：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;
    }
}

在上面的示例代码中，this.x/this.y 指的是当前类，即 Point 类 x 和 y 变量，其中 （double x，double y）是从不同类传递的双精度值，用于将值赋给当前类。

我想分享我从这个关键词中理解的内容。 这个关键字在 java 中有 6 种用法，如下所示：-

1.可用于引用当前类变量。让我们用代码来理解。

让我们通过下面给出的示例来理解如果我们不使用此关键字的问题：

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();  
}}  

输出：-

0 null 0.0
0 null 0.0

在上面的示例中，参数（形式参数）和实例变量是相同的。因此，我们使用此关键字来区分局部变量和实例变量。

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();  
}} 

输出：

111 ankit 5000
112 sumit 6000

2. 调用当前类方法。

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();  
}}  

输出：

hello Natasha
hello Mandy

3. 调用当前类构造函数。它用于构造函数链接。

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);  
}}

输出：

hello ABCD
10

4. 在方法中作为参数传递。

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();  
  }  
}  

输出：

The method is invoked

5.在构造函数调用中作为参数传递

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();  
  }  
} 

输出：-

10

6. 返回当前类实例

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

输出：-

Hello

此外，如果没有 ，则不能使用此关键字。（点），因为它的语法无效。

正如大家所说，这代表了当前对象/当前实例。我是这样理解的， 如果它只是“this” - 它返回类对象，如下所示： 狗 如果它有this.something，则某物是该类中的方法或变量

class Dog {
private String breed;
private String name;

Dog(String breed, String name) {
    this.breed = breed;
    this.name = name;
}

public Dog getDog() {
    // return Dog type
    return this;
}

}

表达式始终引用当前实例。this

• 对于构造函数，当前实例是当前正在构造的新分配对象。
• 对于方法，当前实例是调用该方法的实例。

所以，如果你有一个带有某种方法的类，那么Cm

• 在构造一个新实例的过程中，构造函数的内部将引用 。xCthisx
• 当 是 的实例时，你调用 ，则在 的主体中，将引用该实例。xCx.m()mthisx

下面是演示这两种情况的代码片段：

public class Example {
    static class C {
        public C whatDoesThisInConstructorReferTo;
        public C() {
            whatDoesThisInConstructorReferTo = this;
        }
        public C whatDoesThisInMethodReferTo() {
            return this;
        }
    }
    public static void main(String args[]) {
      C x = new C();
      System.out.println(x.whatDoesThisInConstructorReferTo == x); // true
      System.out.println(x.whatDoesThisInMethodReferTo() == x);    // true
    }
}

关于与 -expression 无关的其他语法元素：this

• 这只是普通会员访问，它的工作方式与所有其他情况下完全相同，在 ..this
• （带圆括号）是构造函数调用的特殊语法，而不是引用。this(...)