Question

通常，我只在构造函数中使用this。

我知道它用于标识参数变量（通过使用this.something），如果它与全局变量具有相同的名称。

但是，我不知道this的真正含义是什么，如果我使用this而没有点（.）会发生什么。

Answer 1

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

如此有效地将它用于多种事物：

澄清你正在谈论一个领域，当还有一个与领域同名的其他东西时
将整个当前对象称为
在构造函数

Answer 2

以下是副本＆amp;来自here的粘贴，但很好地解释了this关键字的所有不同用法：

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

以下是使用方法：

具体表示使用实例变量而不是静态变量或局部变量。也就是说，
```
private String javaFAQ;
void methodName(String javaFAQ) {
    this.javaFAQ = javaFAQ;
}
```
这里指的是实例变量。这里局部变量的优先级高。因此，this的缺失表示局部变量。如果作为参数名称的局部变量与实例变量不同，则无论是否使用this，它都表示实例变量。
This用于引用构造函数
```
 public JavaQuestions(String javapapers) {
     this(javapapers, true);
 }
```
这将调用具有两个参数的同一java类的构造函数。
This用于将当前java实例作为参数
传递
```
obj.itIsMe(this);
```
与上面类似，它也可用于返回当前实例
```
CurrentClassName startMethod() {
     return this;
}
```
注意：在上述两点的内部类中使用时，这可能会导致意外结果。因为这将引用内部类而不是外部实例。

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与其实例相关联，这在静态方法中无效。

Answer 3

要完成，this也可用于引用外部对象

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

Answer 4

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

的内容

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

Answer 5

在Swing中，编写一个实现ActionListener的类并将当前实例（即'this'）添加为组件的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!");
    }

}

Answer 6

如果您致电myObject.method()，则this会引用myObject内的method。

Answer 7

它是“有效地引用当前上下文中的对象”。例如，要打印出“此对象”，您可以写：

System.out.println(this);

请注意，您对“全局变量”的使用有点偏离...如果您使用的是this.variableName，那么根据定义，不是全局变量 - 它是特定于此的变量特殊情况。

Answer 8

它指的是调用该方法的实例

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

Answer 9

对象具有从类派生的方法和属性（变量），以便指定哪些方法和变量属于特定对象，使用this保留字。在实例变量的情况下，理解隐式和显式参数之间的区别很重要。请查看fillTank对象的audi调用。

Car audi= new Car();

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

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

让我们仔细看看fillTank类

中的Car方法

public class Car()
{
   private double tank;

   public Car()
   {
      tank = 0;
   }

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

}

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

java编译器会自动添加this保留字，因此您无需添加它，这是首选项。如果没有点（。），则不能使用this，因为这些是java（语法）的规则。

总结。

对象由类定义，并具有方法和变量
在方法中对实例变量使用this表示实例变量属于隐式参数，或者它是实例隐含参数的变量。
隐式参数是在这种情况下调用方法的对象“audi”。
java编译器自动添加这个保留字，添加它是一个优先选择
this不能在没有点（。）的情况下使用，这在语法上是无效的
this也可用于区分局部变量和具有相同名称的全局变量
this保留字也适用于方法，表示方法属于特定对象。

Answer 10

这个关键字用于引用块的当前变量，例如考虑下面的代码（只是一个例子，所以不要指望标准的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();
 }
}

多数民众赞成。输出将是＆＃34; 2＆＃34;。如果我们没有使用 this 关键字，那么输出将为：0

Answer 11

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

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

Answer 12

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

Answer 13

快速谷歌搜索带来了这个结果：http://xahlee.org/java-a-day/this.html

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

Answer 14

我也在寻找相同的答案，并且无法理解这个概念。但最后我从这个link

中理解了它

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

检查link中的示例以获得清晰的理解

Answer 15

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

class Example{
     int assign;// instance variable

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

希望这有帮助。

Answer 16

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

this.age ---＆gt;当前运行对象的年龄。

Answer 17

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

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

Answer 18

这是指您当前所在的对象。换句话说，这是指接收对象。您可以使用它来澄清您要引用的变量。Java_whitepaper page :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）是从不同类传递的double值，以将值分配给当前类。

Answer 19

（我知道我晚了，但是嘘我是你从未见过我的偷偷摸摸的家伙）

大多数面向对象的编程语言中的 this 关键字（如果不是全部）表示它是对该类当前对象实例的引用。本质上与从名称之外从方法外部调用该对象相同。那可能没有任何意义，所以我会详细说明：

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

object.field

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

this.field

在类内部被调用时， this 关键字实质上替代了对象名称关键字。如果您有两个同名的变量，其中一个是类的一个字段，另一个是方法内部的一个变量，通常没有太多理由这样做，这有助于在两个变量之间进行解密。例如，如果您有：（哈哈，明白了吗？这个？呵呵...。只有我吗？（我现在就离开）

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

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

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

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

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

Answer 20

我想分享一下我对这个关键字的理解。此关键字在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();  
  }  
}

输出：-

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

此外，由于语法无效，因此不能在没有。（。）的情况下使用此关键字。

Answer 21

正如大家所说，这表示当前对象/当前实例。我这样理解如果它只是“ this”-它在以下示例中返回类对象：Dog 如果具有this.something，则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;
}

}

Java中“this”的含义是什么？

21 个答案: