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

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

1
42
MyThisTest a=42

因此，你可以有效地将它用于多种用途:

• 澄清你所说的是一个字段，当还有其他与字段同名的东西时
• 将当前对象作为一个整体引用
• 在构造函数中调用当前类的其他构造函数

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


}

下面是从 给你复制和粘贴，但是很好地解释了 this关键字的所有不同用法:

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

使用方法如下:

1. 明确表示使用实例变量代替静态或局部变量，即,

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

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

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

在编程中引用 文章指南:

在 Java 程序中，this有 两种用途。

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

这种情况下的语法通常类似于

this.someVariable = someVariable;

这里描述了这种类型的使用: “ this”引用(附示例)

2. 调用不同的构造函数

本例中的语法通常类似于

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


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

这里描述了这种类型的使用: 这个(...)构造函数调用(带有示例)

为了完整起见，还可以使用 this来引用外部对象

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

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

Car audi= new Car();


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

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

让我们仔细研究一下 Car类中的 fillTank方法

public class Car()
{
private double tank;


public Car()
{
tank = 0;
}


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


}

在这个班级里我们有一个实例变量“坦克”。可能有许多对象使用 Tank 实例变量，为了指定实例变量“ Tank”用于特定对象，在我们的例子中，我们使用了前面构建的“ audi”对象，我们使用了 this保留关键字。对于 实例变量，在 方法中使用“ this”表示实例变量，在我们的例子中是“ Tank”，是隐式参数的实例变量。

Java 编译器自动添加 this保留字，所以你不必添加它，这是一个偏好问题。如果没有点(.) ，则不能使用 this因为这些是 java 的规则(语法)。

总结一下。

• 对象由类定义，并且具有方法和变量
• 在 方法的 实例变量中使用 this表明，实例变量属于隐式参数，或者它是隐式参数的实例变量。
• 隐式参数是在本例中从“ audi”调用方法的对象。
• Java 编译器会自动添加这个保留字，添加它是一个首选项问题
• 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”。 如果我们没有使用 这个关键字，那么输出将是: 0

我也在寻找同样的答案，但是不知为什么就是不能清楚地理解这个概念。但是最后我从这个 链接中理解了它

这是 Java 中的关键字。它可以在类的方法或构造函数中使用。它(this)作为对正在调用其方法或构造函数的当前对象的引用。关键字可用于引用实例方法或构造函数中当前对象的任何成员。

查看 链接中的例子，以便更清楚地理解

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

class Example{
int assign;// instance variable


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

希望这个能帮上忙。

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

This. age —— > 当前正在运行的对象的 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);






}
}

如果您注意到上面的代码，我们已经启动了三个对象，并且有三个对象正在调用 SetMyInstanceValue 方法。 您认为 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);
}

(我知道我迟到了，但是嘘，我是那个你从未见过的鬼鬼祟祟的男孩)

大多数面向对象编程语言中的 这个关键字(如果不是全部的话)意味着它是对该类的当前对象实例的引用。这本质上与从方法外部通过名称调用该对象相同。这可能毫无意义，所以我不详细说明:

在类之外，为了调用对象实例中的某个对象，例如，假设您有一个名为 object 的对象，并且希望获得一个需要使用的字段

object.field

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

this.field

在类内部调用时，这个关键字实际上替换了 object name 关键字。如果你有两个同名的变量，其中一个是类的字段，另一个只是方法内部的变量，通常没有太多理由这样做，这有助于破译两者之间的关系。例如: (哈，明白了吗? 这个? 呵呵... ... 就我一个人? 好吧: (我现在就走)

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”，意思是它的 这个对象或者 这个实例。在调用类的字段时使用这种方法是一个很好的实践，而不是仅仅使用名称来避免可能的 bug，这些 bug 在编译器运行时很难找到。

这指的是你现在“在”的对象。换句话说，这指的是接收对象。您可以使用这个函数来说明您引用的是.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

在方法中作为参数传递。

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

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

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

返回当前类实例

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”-它返回类对象，在下面的 ex: Dog 如果它有 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始终引用当前实例。

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

因此，如果您有一个具有某个方法 m的类 C，那么

• 在构造 C的新实例 x时，构造函数内部的 this将引用 x。
• 当 x是 C的一个实例，并且您调用 x.m()时，那么在 m的主体中，this将引用实例 x。

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

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

关于与 this表达无关的其他句法成分:

• .只是普通的成员访问，它的工作方式与其他所有情况完全相同，在 this的情况下没有什么特别的事情发生。
• this(...)(带圆括号)是构造函数调用的特殊语法，不是引用。