1. class Hello
   
2. {
   
3. 
   
4.         String s = "Hello";
   
5. 
   
6.         public Hello(String s)
   
7.         {
   
8.                 System.out.println("s = " + s);
   
9.                 System.out.println("1 -> this.s = " + this.s);
   
10.                 this.s = s;
    
11.                 System.out.println("2 -> this.s = " + this.s);
    
12.         }
    
13. 
    
14.         public static void main(String[] args)
    
15.         {
    
16.                 Hello x= new Hello("HelloWorld!");
    
17.         }
    
18. }

复制代码

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

调用构造函数时，成员变量和局部变量重名 都为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!

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

你的问题：

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

楼主没有分清楚成员变量和局部变量。类中成员位置上的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。

字太多有时候容易晕，我就说简单点。

• 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里的形参
• }
• }
  

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

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

变量具有就近访问原则
ring s = "Hello";

05.

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

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

*/
//你这里是建了一个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关键字代表的是本来方法的引用!

大家解释得很清楚，谢谢了！