黑马程序员技术交流社区

标题: 求解this关键字 [打印本页]

作者: 翟宝海 时间: 2013-5-28 17:28
标题: 求解this关键字
本帖最后由翟宝海于 2013-5-29 10:01 编辑

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

复制代码

运行结果为什么是：
s = HelloWorld!
1 -> this.s = Hello
2 -> this.s = HelloWorld!

作者: 萧萧北 时间: 2013-5-28 17:48
调用构造函数时，成员变量和局部变量重名都为s,

首先：局部变量s="HelloWorld!"; 成员变量 s="Hello"

1.构造函数中System.out.println("s = " + s);
这里s 默认调用的是局部变量,所以结果为：s = HelloWorld!
2.System.out.println("1 -> this.s = " + this.s);
此处使用this, this引用表示对象本身引用，所以调用了类的成员变量，而成员变量值为String s = "Hello";
所以结果为：1 -> this.s = Hello
3.this.s = s; //将局部变量的值赋值给成员变量
System.out.println("2 -> this.s = " + this.s);
所以此处输出值为：2 -> this.s = HelloWorld!

作者: 381946250 时间: 2013-5-28 17:57
首先先解释下this：
  第一、通过this调用另一个构造方法，用发是this(参数列表)，这个仅仅在类的构造方法中，别的地方不能这么用。
      第二、函数参数或者函数中的局部变量和成员变量同名的情况下，成员变量被屏蔽，此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。当然，在没有同名的情况下，可以直接用成员变量的名字，而不用this，用了也不为错，呵呵。
      第三、在函数中，需要引用该函所属类的当前对象时候，直接用this。

你的问题：

小Q截图-20130528175715.png (19.99 KB, 下载次数: 0)

作者: 归☆夜↑『 时间: 2013-5-28 18:12
this是主要是用于当实例变量和局部变量同名时区分两者的关键字。
当方法中局部变量与实例变量同时存在且同名时,方法中的局部变量会覆盖实例变量，因此可以实用this关键字显示告诉系统使用的是实例变量。
在public Hello（“HelloWord!”）构造器中，s指向的是局部变量即"HelloWord!" this.s指的是实例变量即"Hello"，在代码的第十行this.s=s语句将局部变量即"HellpWord"赋值给实例变量,即this.s的值变为HelloWord!打印出来就是上面的结果啊

作者: 赵崇友 时间: 2013-5-28 19:26
楼主没有分清楚成员变量和局部变量。类中成员位置上的s为成员变量（字段），构造函数中的s是局部变量。
this是指本类对象的引用。谁在创建对象，就是指谁的引用。只可以通过this引用获得本类对象中的成员变量和方法，是不能得到局部变量的。如果在局部位置上，有和成员变量相同名称的变量，则要想引用成员变量则必须使用this关键字，不加this默认使用的是局部变量。如果，局部位置上使用的和局部变量不同名的变量，可以不加this关键字，系统默认的有this。
new Hello("HelloWorld!"); 这时会加载Hello类，并初始化类中的成员变量s=“Hello”，然后到构造函数中，由于构造函数是有参的，所以此时new Hello("HelloWorld!")会将“Hello World”以参数的形式传递给有参数的构造函数，此时构造函数中的s=“Hello World”。执行到System.out.println("s = " + s); 时打印的是局部变量上的s，也就是Hello World。执行到System.out.println("1 -> this.s = " + this.s);this.s是本类对象引用类中的成员变量s，所以打印的是 Hello 。
this.s = s;这句是将局部变量s赋值给成员变量s。这时成员变量和局部变量指向了相同的内容Hello World。所以System.out.println("2 -> this.s = " + this.s); 会打印Hello World。

作者: 李征 时间: 2013-5-28 20:14
字太多有时候容易晕，我就说简单点。

class Hello
{
String s = "Hello";
public Hello(String s) //第二步：这里的String s就是形参，由实参传递进来了"helloworld!"
{
System.out.println("s = " + s); //第三步：打印这个形参S，也就是刚刚传递进来的"helloworld!"
System.out.println("1 -> this.s = " + this.s); //第四步：this.s就不是传递进来的参数了，而是第四行的String s = "Hello"，因为this是在调用成员变量，视频里有说明
this.s = s; //第五步：使成员变量String s = "Hello",指向形参s，也就是“helloworld!”
System.out.println("2 -> this.s = " + this.s); //第六步：打印这个刚刚被修改的成员变量this.s，也就是“hellowprld!”，这么说应该比较容易理解
}
public static void main(String[] args)
{
Hello x= new Hello("HelloWorld!"); //第一步：把“helloworld!”作为实参传递给构造函数hello里的形参
}
}

我也在学习中，有什么不对请指正哦

作者: 风爽 时间: 2013-5-28 20:46
public Hello(String s)                   //1
      {
            System.out.println("s = " + s);    //这里的s相当于一个局部变量，就是传进来的参数
            System.out.println("1 -> this.s = " + this.s);  //加上this关键字就是调用成员变量中的s，即“Hello”
            this.s = s;                      //这里将成员变量中的s和传的形参指向同一个引用“Helloword”
            System.out.println("2 -> this.s = " + this.s);
      }

作者: 韩明海 时间: 2013-5-28 21:02
变量具有就近访问原则
ring s = "Hello";

05.

06. public Hello(String s)
成员s在方法外面，参数s在方法内，所以优先访问参数里的s,那么输出就是helloworld.
this 是对本类的引用，所以this.s,就是对成员变量s的访问，那么输出hello.
将参数的s赋值给成员的s,所以最后输出helloworld.

作者: 王林涛 时间: 2013-5-28 21:38
本帖最后由王林涛于 2013-5-28 21:41 编辑

/**
      首先哥们儿你懂你自己在做什么吗?

*/
//你这里是建了一个Hello类
class Hello
{
            //然后定义一个String(字符串)变量s,然后赋值为Hello
      String s = "Hello";
      //建立一个Hello构造方法,括号里的String s,为传入的参数
      public Hello(String s)

      {             //输出打印s
            System.out.println("s = " + s);
                              //输出打印"1 -> this.s"this.s
                              System.out.println("1 -> this.s = " + this.s);
                              //this代表本类对象的引用
                                          this.s = s; //先输出它,因为上面是个构造方法,先运行构造方法,所以先输出s = HelloWorld!
                              //然后输出"2 -> this.s"
            System.out.println("2 -> this.s = " + this.s);
      }
            //这里是主函数方法体
      public static void main(String[] args)
      {             //创建一个对象x,并传入参数"HelloWorld"
            Hello x= new Hello("HelloWorld!");
      }
}
我告诉你为什么运行结果是
s = HelloWorld!
this.s = s; //先输出打印它,因为上面是个构造方法,下面建立的对象直接调用构造方法,程序先执行构造方法,所以先输出s = HelloWorld!

然后就是顺序打印输出了!
1 -> this.s = Hello
2 -> this.s = HelloWorld!

记住哈哥们儿,this关键字代表的是本来方法的引用!

作者: 翟宝海 时间: 2013-5-29 10:00
大家解释得很清楚，谢谢了！

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

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