黑马程序员技术交流社区

标题: this关键字的用法 [打印本页]

作者: 番茄君 时间: 2016-5-10 18:46
标题: this关键字的用法
这个this关键字到底是指什么东西,什么时候可以用,什么时候不用,我看书上说有时候还可以省略.再就是经常看到什么this.name=name,我去,名字等于名字,看到就蒙蔽了?this到底怎么用啊

作者: a48702668 时间: 2016-5-10 22:07
this就是指调用他的方法所归属的类，个人理解。

作者: runner 时间: 2016-5-10 22:31
this关键字是在方法重名的时候用,一般只是在面试的时候会提到,在开发的时候是不会出现的.
还有this是在方法下的,谁来调用我所在的方法下,我就代表谁.你所说的是在有参构造下.

public Student () {} // 空参
public Student(String name, int age){ //有参
this.name = name;
this.age =age;
}
比如上面说的,那谁来调用有参,this就代表谁 !希望对你哟帮助!!!

作者: 1334071171 时间: 2016-5-11 11:03
谁来调用有参,this就代表谁

作者: mischen 时间: 2016-5-11 15:10
java中this一般有两种用法，一种用法是代表当前类，常见的就是this.name=name，表示当前类的名字默认为就是这个name了，具体怎么说呢，这得调用的时候你就清楚了。第二种就是在构造函数中使用，在构造函数中使用一个到两个参数，然后调用this，具体的有很多书籍和百度都可以参考。一般来说比较简单，也容易理解。你可以自己先看看，不理解再问

作者: mischen 时间: 2016-5-11 15:11
java中this一般有两种用法，一种用法是代表当前类，常见的就是this.name=name，表示当前类的名字默认为就是这个name了，具体怎么说呢，这得调用的时候你就清楚了。第二种就是在构造函数中使用，在构造函数中使用一个到两个参数，然后调用this，具体的有很多书籍和百度都可以参考。一般来说比较简单，也容易理解。你可以自己先看看，不理解再问

作者: 钟毅 时间: 2016-5-11 20:16
本帖最后由钟毅于 2016-5-11 20:18 编辑

this一般最多用在javabean中的getter和setter方法中，用来区分名字一样的成员变量和形式参数的。还有就是在本类中调用本类的构造方法和一般方法是
也可以用this.来表明，怕的是重写的父类方法冲突了。

作者: scalar 时间: 2016-5-11 22:20
this一般代表当前对象。
从自己某个类的另一个方法内部调用一个类方法，就不必使用this，只需直接调用那个方法
即可。
有时候类中成员函数自变量的名字以及类成员数据的名字是相同的，为了避免混淆，可以用this来引用成员数据。

作者: ypenghui 时间: 2016-5-11 23:05
this.name = name
举个例子：
//定义一个Person类
class Person{
   //成员变量
   private String name;
//成员方法
   public void setName(String name){
      this.name = name;
   //****请注意，这里等式右边是指成员方法setName(name)中的 name;  左边是指成员变量中的 name；this代表当前对象对成员变量的调用。
   //****换种思考，若无this, name = name; 我们会弄不清name 的值究竟付给自己本身还是付给谁。
   }
}

作者: ypenghui 时间: 2016-5-11 23:11
希望对你有帮助

作者: glacial 时间: 2016-5-12 09:41
从继承的角度理解，this与super是相对的，一般在有继承状态出现的时候出现。this表示调用本类的方法或变量，而super是调用父类的

作者: gjtdxjd 时间: 2016-5-13 19:10
this是用来区分成员变量和局部变量重名的,当给成员变量中的 name赋值的话,java中根据就近原则,只会赋值给局部变量name赋值,而不会赋值给成员变量name,this.中记录的是主方法中创建的对象的值 ,this.name就是主方法中被创建的对象.

作者: chexinxin 时间: 2016-5-13 23:22
本帖最后由 chexinxin 于 2016-5-13 23:27 编辑

this关键字主要作用有 1，可以明确地去访问一个类的成员变量，解决与局部变量名称冲突问题；
2，通过This关键字调用成员方法；
3，构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能像调用其它方法一样去调用构造方法，但可以在一个构造方法中使用this([参数1，参数2......])的形式调用其它构造方法；
还有在继承中可以调用父类的构造方法

作者: 罗勇 时间: 2016-5-14 11:53
本帖最后由罗勇于 2016-5-14 11:57 编辑

首先明白:成员变量用对象 .  来调用。也就是this. age调用成员变量age。
            局部变量是方法里，方法体上的变量。
先实例一个类对象 Person p1 =new Person();
下面p1调用setName 方法  p1.setAge(18)；

class Person{
private String name;
private int age;
public void setAge (int age){
this.age = age;//右边的age就是setAge里的参数（int age）,左边的this代表对象，也就是最上面的p1，也就是说p1调用setAge方法，this.age就是p1将自己的成员变量age赋值; 这样就把成员变量的age(就是private int age)与局部变量（setAge里的age,也就是等号右边的age）区分开来了。如果局部变量里的不是int age ,而是int a，就不需要用this来调用了.例如下面的代码2
}
}

复制代码

代码2：

class Person {
private int age;
public void setAge (int a) {
age = a;//这里的局部变量为a，与成员变量age不重名了，不需要区分成员变量与局部变量，所以不用this来代表当前对象（p1）的引用了。
}
}

复制代码

说到底就是怕你如果写成这样
pubilc void setAge (int age) {
age = age;//这么写俩age都是局部变量的了，所以无法赋值给成员变量上的age（就是private int age里的age）,所以就用个this来代表当前对象（p1）的引用。成员变量用对象 . 来调用。也就是this. age调用成员变量age。
｝这已经是我写过的最详细的解释了，希望楼主给分奖励。不明白可以继续问的。

作者: 15102755269 时间: 2016-5-14 22:07
用于构造方法中的,代表所指向有参构造的变量,方法

作者: 向前_KCmhn 时间: 2016-5-14 23:09
可以把this理解为一个未知数x，而创建一个在这个x类中的对象，就是给这个x赋值。
而这个this就可以理解为这个对象的替身。
最好形成自己的理解逻辑。这样才能学好java

作者: 向前_KCmhn 时间: 2016-5-14 23:11
等你自己理解这个this的作用，之后就可以看看书上讲的，怎么用Java的官方语言去形容它。

作者: Sj改变 时间: 2016-5-17 18:54
表示当前这个类的实例对象的name

作者: rogerpbj 时间: 2016-5-21 02:53
this表示的是当前调用对象，哪个对象用到这个方法，this就表示哪个对象

作者: climb 时间: 2016-5-21 23:13
1.    当成员变量和局部变量重名时，在方法中使用this时，表示的是该方法所在类中的成员变量。（this是当前对象自己）

如：public class Hello {

String s = "Hello";

public Hello(String s) {

   System.out.println("s = " + s);

   System.out.println("1 -> this.s = " + this.s);

   this.s = s;//把参数值赋给成员变量，成员变量的值改变

   System.out.println("2 -> this.s = " + this.s);

}

public static void main(String[] args) {

   Hello x = new Hello("HelloWorld!");

   System.out.println("s=" + x.s);//验证成员变量值的改变

}

}

结果为：s = HelloWorld!

1 -> this.s = Hello

2 -> this.s = HelloWorld!

s=HelloWorld!

在这个例子中，构造函数Hello中，参数s与类Hello的成员变量s同名，这时如果直接对s进行操作则是对参数s进行操作。若要对类Hello的成员变量s进行操作就应该用this进行引用。运行结果的第一行就是直接对构造函数中传递过来的参数s进行打印结果；第二行是对成员变量s的打印；第三行是先对成员变量s赋传过来的参数s值后再打印，所以结果是HelloWorld!而第四行是主函数中直接打印类中的成员变量的值，也可以验证成员变量值的改变。

2．把自己当作参数传递时，也可以用this.(this作当前参数进行传递)

   class A {

public A() {

   new B(this).print();// 调用B的方法

}

public void print() {

   System.out.println("HelloAA from A!");

}

}

class B {

A a;

public B(A a) {

   this.a = a;

}

public void print() {

   a.print();//调用A的方法

   System.out.println("HelloAB from B!");

}

}

public class HelloA {

public static void main(String[] args) {

   A aaa = new A();

   aaa.print();

   B bbb = new B(aaa);

   bbb.print();

}

}

结果为：HelloAA from A!

HelloAB from B!

HelloAA from A!

HelloAA from A!

HelloAB from B!

在这个例子中，对象A的构造函数中，用new B(this)把对象A自己作为参数传递给了对象B的构造函数。

3．       有时候，我们会用到一些内部类和匿名类，如事件处理。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。如：

public class HelloB {

int i = 1;

public HelloB() {

   Thread thread = new Thread() {

         public void run() {

            for (int j=0;j<20;j++) {

               HelloB.this.run();//调用外部类的方法

               try {

                  sleep(1000);

               } catch (InterruptedException ie) {

               }

            }

         }

   }; // 注意这里有分号

   thread.start();

}

public void run() {

   System.out.println("i = " + i);

   i++;

}

public static void main(String[] args) throws Exception {

   new HelloB();

}

}

在上面这个例子中, thread 是一个匿名类对象，在它的定义中，它的 run 函数里用到了外部类的 run 函数。这时由于函数同名，直接调用就不行了。这时有两种办法，一种就是把外部的 run 函数换一个名字，但这种办法对于一个开发到中途的应用来说是不可取的。那么就可以用这个例子中的办法用外部类的类名加上 this 引用来说明要调用的是外部类的方法 run。

4．在构造函数中，通过this可以调用同一类中别的构造函数。如：

      public class ThisTest {

ThisTest(String str) {

   System.out.println(str);

}

ThisTest() {

   this("this测试成功！");

}

public static void main(String[] args) {

   ThisTest thistest = new ThisTest();

}

}

为了更确切的说明this用法，另外一个例子为：

public class ThisTest {

private int age;

private String str;

ThisTest(String str) {

   this.str=str;

   System.out.println(str);

}

ThisTest(String str,int age) {

   this(str);

   this.age=age;

   System.out.println(age);

}

public static void main(String[] args) {

   ThisTest thistest = new ThisTest("this测试成功",25);



}

}

      结果为：this测试成功

25



值得注意的是：
1：在构造调用另一个构造函数，调用动作必须置于最起始的位置。
2：不能在构造函数以外的任何函数内调用构造函数。
3：在一个构造函数内只能调用一个构造函数。

5．this同时传递多个参数。

public class TestClass {

int x;

int y;

static void showtest(TestClass tc) {//实例化对象

   System.out.println(tc.x + " " + tc.y);

}

void seeit() {

   showtest(this);

}

public static void main(String[] args) {

   TestClass p = new TestClass();

   p.x = 9;

   p.y = 10;

   p.seeit();

}

}

结果为：9 10

代码中的showtest(this),这里的this就是把当前实例化的p传给了showtest（）方法，从而就运行了。

作者: 68帅锅 时间: 2016-5-21 23:27
代表当前类的对象的引用.用于区分成员变量与局部变量重名.

作者: 即墨 时间: 2016-5-21 23:33
谁调用我，我就代表谁

作者: yiyajing 时间: 2016-5-23 01:58
说白了就是谁调用就是谁的，子类调用就是指子类，父类调用就是父类

作者: fanhongwei1105 时间: 2016-5-23 21:41
小编认为，要理解super,要和this一起作比较 1、成员变量 this代表对调用本类成员变量，本类中没有时会去父类中寻找。 super调用父类成员变量； 2、调用构造函数 this()调用本类的构造方法 super()调用父类的构造方法 3、调用成员方法 this.调用本类的成员方法，当本类没有时，调用父类的 super.调用父类的成员方法 this代表对当前对象的引用，谁调用我，我就代表谁；当本类中没有时才会调用父类。 super代表对父类的引用；

作者: hjbing456 时间: 2016-5-23 23:00
this代表本类对象，this.name = name；就是用来区分局部变量和成员变量的。当本类中没有这个对象的时候会从继承的父类中寻找。
this ：谁来调用我，我就代表谁。
this 一般出现在有参的构造方法中

作者: zyp1343832 时间: 2016-5-23 23:49
一般是指的当前参数的调用

作者: 我love 时间: 2016-5-25 01:41
this其实是代表对象，而且是任意对象，但是这样范围太大肯定是不行的，所以其实this是代表当前类的对象，this在哪个类里面，就代表这个类的对象，然后这个类的某个对象使用this，this就代表这个对象

作者: 安卓大神007 时间: 2016-5-26 15:49
this关键字是用来解决成员变量和局部变量重复命名的，这里简单介绍一下，成员变量是在类中方法外，局部变量是在类中方法中。在实际使用额过程中，根据不同的场景有不同的需求，因此需要能够对两个属性值都可以调用。可以的话你敲一遍就可以了解了。举个例子看起来应该比较直观：
//类A中的main方法中进行功能测试，类B中的method对类B中的变量进行输出，分别是带this和不带this的
class A
{
   public static void main(String[] args){
         //新建对象
         B b=new B():
         //调用方法的时候就会执行其中的语句
         b.method();
   }
}
class B
{
   //这是类中方法外的属性值
   String name="lisi";
   //在此方法中进行输出
   public void method(){
   //这是类中方法中的属性值
   String name="zhangsan";
   System.out.println(“方法中的属性值”+name);
   System.out.println(“方法外的属性值”+this.name);
   }
}

作者: 车前子008 时间: 2016-5-26 16:12
this.name=name中, this.name是本对象的成员属性, 刚开始没有赋值, name 是传进去的参数 , 然后赋值给 this.name..单独使用时,代表本类对象

作者: 欧胤祥 时间: 2016-5-26 16:31
this 指向当前实例对象的引用,谁来调用我我就代表谁

作者: 流离岁月 时间: 2016-5-26 20:39
this.name指的是本类的name,而等号后面的name指的是调用方法所传递的参数name,记住一点this是本类对象的引用就可以区分了

作者: 流离岁月 时间: 2016-5-26 20:40
this.name指的是本类的name,而等号后面的name指的是调用方法所传递的参数name,记住一点this是本类对象的引用就可以区分了

作者: 上帝的天使 时间: 2016-5-30 00:18
嗯，好多呢。

作者: 元笙 时间: 2016-5-31 00:03
第一,你要明白为什么Java要提供this关键字(使用场合)
this关键字第一种应用场合是,解决局部变量隐藏成员变量的问题,具体看下面代码

/*
*[this关键字的第一种用法]:解决了局部变量隐藏成员变量的问题(前提是同名)
*/
class DemoThis {
public static void main(String[] args) {
}
}
//创建一个类Student
class Student {
//成员变量(事物的属性)
String name; //学生有姓名吧
String grade; //学生分班级吧
//...
//无参构造器和有参构造器
public Student(){}
/*
*第一种情况,如果形参(局部变量)不和成员变量name同名
*这种情况少,因为变量名建议"见名知意",n和g很明显看不出什么意思
*/
public Student(String n,String g){
name = n;
grade = g;
}
/*
*第二种情况,如果局部变量和成员变量同名了
*就会出现局部变量变量把成员变量的"隐藏"了
*因为Java会采用就近原则,访问最近的变量
*/
public void set(String name,String grade){
name = name;
grade = grade;
//这样写,能按照我们预期的想给Student类对象的name属性和grade属性赋值?
//这里,不能实现,因为局部变量name和grade会给自己赋值
}
}

复制代码

this的第二种应用场景,就是调用本类的构造方法
第二,你要明白为this是什么
this其实就是一个地址,那个对象调用this所在的方法,this就代表那个对象,也可以说this是该对象的引用
第三,你要知道什么时候this可以省略
在第一种情况,只要保证不出现同名变量,就无需显式在变量前面加上this.
在第二种情况,系统默认即可

作者: 土菠萝 时间: 2016-5-31 11:42
如果有两个同类型的对象，分别叫作a 和b，那么您也许不知道如何为这两个对象同时调用一个f()方法：
class Banana { void f(int i) { /* ... */ } }
Banana a = new Banana(), b = new Banana();
a.f(1);
b.f(2);
若只有一个名叫f()的方法，它怎样才能知道自己是为a 还是为b 调用的呢？

this 关键字（注意只能在方法内部使用）
可为已调用了其方法的那个对象生成相应的句柄。

this就是让你知道哪个对象在调用方法

作者: 921717549 时间: 2016-6-1 12:58
super,this关键字的作用及用法
?       在Java类中使用super来引用父类的成分
-       可用于访问父类中定义的属性super
-       可用于调用父类中定义的成员方法super
-       可用于在子类构造器中调用父类的构造器super
-       的追溯不仅于直接父类super
?       中为解决变量的命名冲突和不确定性问题，引入关键字“this”代表其所在方法的当前对象。Java
-       构造器中指该构造器所创建的新对象
-       方法中指调用该方法的对象
?       关键字的用法this
-       在类本身的方法或构造器中引用该类的实例变量和方法
-       将当前对象作为参数传递给其它方法或构造器
-       用来调用其他的重载的构造器

作者: 921717549 时间: 2016-6-1 13:00
      关键字的用法this
-       在类本身的方法或构造器中引用该类的实例变量和方法
-       将当前对象作为参数传递给其它方法或构造器
-       用来调用其他的重载的构造器

作者: dreamhunter 时间: 2016-6-2 19:08
这个this就是代指调用这个类的对象的地址

作者: 毅往志乾 时间: 2016-6-3 14:49
谢谢楼主!我也有这个问题了,来看看现成答案

作者: 毅往志乾 时间: 2016-6-3 15:10

ypenghui 发表于 2016-5-11 23:05
this.name = name
举个例子：
//定义一个Person类

这个回答好!谢谢!

作者: wzl100520 时间: 2016-6-4 20:59
this是当前的类的属性，，，一般在构造和get/set中出现，，方法中使用本类可以省略，因为java默认为就近原则

作者: 再来一个果丹皮 时间: 2016-6-5 00:43
以下两种情况，必须显示的使用this
1).局部变量覆盖成员变量时：如果想要访问被覆盖的成员变量，必须显示的使用this.成员变量名
2).在一个构造方法内，调用另一个构造方法时，需要使用：this([实参]);

作者: 奕明传媒 时间: 2016-6-6 16:40
this用来区分同名变量，你所说的name是成员变量，加上this是指当前作用域范围内的变量

作者: cuisq 时间: 2016-6-6 23:31
一般来说: 区分变量的,调用者的和类里面的(局部变量)

作者: ypenghui 时间: 2016-6-9 21:19
客气了！！！

作者: TheLittlePrince 时间: 2016-6-13 21:09
例如:String name ;
   int age;
   public Person() {}
   public Person(String name,int age) {
         this.name=name;
      this.age=age;
}
其中的成员变量名和局部变量名重复:name和age/为了区分,所以用this来区分,就是谁来调用我,我就代表谁,"我"就是指"this"关键字,他跟谁在一块就代表谁,等号左边的就代表this.name代表的就是成员变量,
后面还有的就是this和super在调用方法的时候也会用到!

作者: zhuhongbo 时间: 2016-6-16 22:13
this表示指向对象自己的引用。
我们知道方法中既可以使用实例变量，也可以使用方法中的局部变量。那么当实例变量与局部变量重名的时候，方法中默认的是先使用局部变量，这时如果是想使用实例变量需要用this。

举个例子：
public class Students{
public String name;
public void test( String name){
this.name = name;
//前面this.name的name是成员变量，等
//号右边的name是方法中的形参
//如果形参的名字不是name，this可以
//省略
}
}

复制代码

当new一个Students的对象调用方法test的时候，this就表示调用这个方法的对象。对象和类不清楚的可以百度，其实还是很容易理解的。

作者: lizihanglove 时间: 2016-6-20 23:06
通俗点来说就是:我儿子(类)的名字(属性)还没有取，现在看见隔壁村有个叫王二的，我就把王二这个名字赋予我儿子，然后我儿子就有名字了。

作者: lizihanglove 时间: 2016-6-20 23:09
前面一个name是该类的属性，后一个name是构造方法传入的参数，为了区分两个量，才把this加上，以区分两个变量(或属性)。

作者: 天之骄子no1 时间: 2016-6-25 23:17
this一般会出现在setter和getter方法中，主要就是为了区别开局部变量和成员变量的重名问题。this带表当前对象的引用。

作者: 15620608429 时间: 2016-6-27 00:04
this的用法有下面的两种

作者: 15620608429 时间: 2016-6-27 00:06
this的用法有下面的两种
1、是表示当前类的引用，谁使用this就表示谁。
2、成员变量和局部变量一致时区分成员变量和局部变量；

作者: ssd123mn 时间: 2016-6-29 00:49
this通俗点理解就是代表当前创建的对象，this.name 代表对象的变量，name代表局部的变量，两个不同的，还是要理解明白

作者: ssd123mn 时间: 2016-6-29 00:51
this通俗点理解就是代表当前创建的对象，this.name 代表对象的变量，name代表局部的变量，两个不同的，还是要理解明白

作者: itshenma 时间: 2016-7-8 23:43
super和this super调用构造方法的作用：子类通过调用父类的构造方法，给父类的成员变量赋值调用成员变量和成员方法 this.成员变量名 super.成员变量名 this.方法名(实际参数) super.方法名(实际参数) 调用构造方法 this调用本类的无参 this() this调用本类的有参 this(实际参数) super调用父类的无参 super() super调用父类的有参 super(实际参数) 注意事项：this和super调用构造方法，必须放在第一行案例 class Fu { public String name = "我是爸爸"; } class Zi extends Fu{ public String name = "我是儿子"; public void show(String name){ System.out.println(name); //输出呵呵 System.out.println(this.name); //输出我是儿子 this:表示从本类成员位置开始找name属性，找到了就使用，找不到就从父类的成员位置找，找到了就使用，找不到就报错 System.out.println(super.name); //输出我是爸爸 super:表示从父类的成员位置开始找，找到了就使用，找不到就报错 } } class Test{ public static void main(String[] args) { Zi zi = new Zi(); zi.show("呵呵"); } }

作者: feng19900123 时间: 2016-7-10 10:23
this指向对象本身，谁调用就指向谁，可以理解为它所在的类的类名，用来区分成员变量与局部变量重名。this只有在创建对象后才能存在，所以在静态方法中不可使用this,因为静态的方法是优先于对象存在的。

作者: linguoqun 时间: 2016-7-26 02:27
楼主，你好！很高兴回答您的问题！
this代表当前对象。意思是“我的”，楼主可以这么理解，不会有任何问题。
解决这个问题有两个方法，一个是通过在开发工具中，将源代码写下，源代码会自动将两个name用不同颜色标记，这样你一看就能区分它们，并一眼能看出它们的含义了。
好的，如果上面的方法还不能完全帮你解决问题，那么请听我用代码给您解释：代码如下：
public class Test05 {

public static void main(String[] args)
{
Person p1=new Person();
p1.age=18;
p1.Print(p1.age);
}

}
class Person
{
int age=0;

public void Print(int age)
{

this.age=age;
System.out.printf("我的年龄是%d",age);
}

}
我先讲一下他们之间的关系：其实很简单的，楼主听一下就懂：
this.age这里的age 代表当前类person中的属性age.而等号右边的age其实是方法的形参。
我们的语言其实有一点挺好的，为什么会有this的出现呢？因为有了this，系统会告诉编绎器，哪个是属于当前类的，哪个是形参传进来的。
好的，第二层意思是：我们都知道，调用方法要用到对象，只有有了对象，才能调用方法，好了。当我们用对象调用一个方法的时候，这个方法如果有this关键字，那么，这个this 关键字可以理解为这个对象本身。
这么说应该明白了吧？
纯手打的，满意请采纳，谢谢！

作者: raining 时间: 2016-7-28 23:20
(1)this:代表当前对象的引用,谁来调用我,我就代表谁
(2)super:代表当前对象父类的引用
(3)this和super的使用区别
a.调用成员变量
* this.成员变量调用本类的成员变量,也可以调用父类的成员变量
* super.成员变量调用父类的成员变量
b.调用构造方法
* this(...) 调用本类的构造方法
* super(...) 调用父类的构造方法
c.调用成员方法
* this.成员方法调用本类的成员方法,也可以调用父类的方法
* super.成员方法调用父类的成员方法

作者: 花陌相惜 时间: 2016-7-31 16:19
this关键字的理解
(1)this只能代表本类对象
(2)this代表所属函数(方法)的所属对象
(3)谁来调用我，我就代表谁
(4)this可用于区分成员变量和局部变量同名的情况

作者: linguoqun 时间: 2016-8-4 00:59
楼主你好！
这个问题是初学者一般容易比较蒙圈的地方。
其实一旦弄清楚它的原理，就很容易理解了。
java是为了区分当前类的属性和函数传进来的参数所以才引入了this的概念。这一点希望楼主先弄明白。
当前类的属性假如已经定义了一个属性叫name，但是函数有一个参数也叫name，那么想把实际传给形参的name赋值给当前类的属性name时，编绎器就搞不懂你写的name到底是哪个name，你想把哪个name赋值给哪个name. 所以，为了能够区分开，就加入了this关键字。
this关键字的意思是“我的”，就代表当前类的对象。哪个对象调用了这个函数，那么这个对象的name就用this.name来表示。希望楼主明白。
纯手打的，满意请采纳，谢谢！有不懂的还可以继续提问哦。

作者: Flowert 时间: 2016-8-4 13:38
个人理解：

/*
1.区别成员变量和局部变量重名时，如下：
如果输出语句里面的num时，输出的时90，就近原则，
如果要输出10，就要用this.num
意思就是在一个方法内，如果有重名的变量，直接使用的就是局部变量，this.使用的就是成员变量
class Test {
public static void main(String[] args) {
Demo d = new Demo();
d.print();
}
}
class Demo {

int num = 10;
public void print(){
int num = 90;
System.out.println(num);
}
}

2.this代表本类对象的引用，说的通俗点就是：
哪个对象调用了this所在的函数，this就代表这个对象。
this用途：解决局部变量隐藏成员变量的问题
*/

作者: Liangfwu 时间: 2016-8-10 23:03

，我刚学的时候也是和你一样，其实this是用来区分局部变量和成员就是的，如果在一个方法体里写了this.xx , 那这个xx就指向了方法体外部的那个成员变量，如果本类中没有那个变量，那就找他的父类了，而＝号右边的xx就是方法体里面的变量，我是这样理解的

作者: 雪连城 时间: 2016-8-29 22:11
6666666666666666666

作者: aa909809588 时间: 2016-9-8 21:01
调用this这个关键字所在类的对象，比如有个学生类Student里面用到this关键字，那么它就代表学生类的对象new Student()

作者: Fate_stay 时间: 2016-9-9 01:00
this关键字：
1.this.方法名() , 这里this指当前对象
2.this.属性名，同理，也只当前对象。加上this的目的是为了区分成员变量和局部变量
比如：public void setName(String name) {
this.name = name;
}
this. 后面的name 是属性name，而后面的name是传过来的参数
3.this可以用来代码提示，不知道调用什么方法的时候，用this加个点，后面的方法名就出来了

作者: 芳燚乐乐 时间: 2016-9-11 00:24
1:当成员变量和局部变量重名时，在方法中使用this时，表示的是该方法所在类中的成员变量。（this是当前对象自己）
2:把自己当作参数传递时，也可以用this.(this作当前参数进行传递)
3:有时候，我们会用到一些内部类和匿名类，如事件处理。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。
4:在构造函数中，通过this可以调用同一类中别的构造函数。
值得注意的是：
a:在构造调用另一个构造函数，调用动作必须置于最起始的位置。
b:不能在构造函数以外的任何函数内调用构造函数。
c:在一个构造函数内只能调用一个构造函数。
5:this同时传递多个参数。
以上仅仅只是个人的小认识!

作者: i'm 时间: 2016-9-17 23:17
当前对象的引用，希望楼主采纳！！！

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2