package mianxiangduixiang;
public class HeimaThis {
    public static void main(String[] args)
    {
         HeimaThis ht=new HeimaThis("黑马程序员");     //1
    }
    String s = "黑马";                                                 //2
    public HeimaThis(String s)                                    //3
   {
          System.out.println("s = " + s);                       //4
          System.out.println("a：this.s = " + this.s);     //5
          this.s = s;                                                   //6
          System.out.println("b：this.s = " + this.s);     //7
      }
}
运行结果：
s = 黑马程序员
a：this.s = 黑马
b：this.s = 黑马程序员
    半夜看的我头疼眼花把我看晕了，哪位好心人可以帮我解释一下这个程序，我知道  程序执行后堆内存1的参数传到3中去，所以4打印的是“黑马程序员”，5中的this.s调用的是2.
但是我想知道的是。6中的this.s=s是什么意思？7中为什么也会打印出“黑马程序员”

下面是我的理解，如有说错的地方，还请拍砖：
System.out.println("s = " + s);                       //4
System.out.println("a：this.s = " + this.s);     //5
this.s = s;                                                   //6
System.out.println("b：this.s = " + this.s);     //7
当主函数执行到第1句的时候，调用了HeimaThis这个类的构造方法，构造函数就接收到了实参：“黑马程序员”
此时，这个实参就传递给了构造方法中的形式参数s
第4句：由于在构造函数中有参数s，属于局部变量，所以执行到第4句的时候，会首先访问局部变量s，而此时局部变量已经接收到了你传递给它的实参：“黑马程序员”，所以就打印了这个。
第5句：你在s前面加了this关键字，代表对象引用，此时，就会去访问HeimaThis类中的成员变量s，所以打印的是黑马。
第6句：你将形式参数s接收到的值赋给了类中的成员变量s
第7句：打印出来的就是被赋值后的成员变量，就是“黑马程序员”。
关键是你构造函数中的形式参数和类中的成员变量同名了，所以才会有点晕，呵呵...多琢磨就明白了。

package mianxiangduixiang;
public class HeimaThis {
    public static void main(String[] args)
    {
         HeimaThis ht=new HeimaThis("黑马程序员");     //1这里创建了heima类的一个对象
    }
    String s = "黑马";                                                 //2
    public HeimaThis(String s)                                    //3
   {
          System.out.println("s = " + s);                       //4这里的s是指局部变量S，当然是打印“黑马程序员”
          System.out.println("a：this.s = " + this.s);     //5这里的this.s调用的是成员变量S，因此打印“黑马”
          this.s = s;                                                   //6这里等式的左边的S因为被this修饰，所以是指类中成员变量，而右边的s则是函数中的局部变量。该句代码的意思是把局部变量s的值传给了成员变量S，s的值变成“黑马程序员”，调用输出的结果自然是“黑马程序员”
          System.out.println("b：this.s = " + this.s);     //7
      }
}

当函数中传递参数的局部变量与成员变量同名诗，就可以用this来区分成员变量和局部变量，被this修饰的是成员变量
另外楼主可以把构造函数放在main函数之前，这样看起来会比较直观一些。

this为一系统资源，只允许用户读而不允许写，它存放当前对象的地址(引用)
this变量有以下作用：
1. 构造方法重用：
public class Rectangle
{
public Rectangle(Location at, Shape size)
{…}
public Rectangle(Shape size,Location at)
{
  this(at, size);
}
public Rectangle(Location at)
{
  this(at, new Shape(100,100));
}
public Rectangle(Shape size)
{
  this(size, new Location(1,1));
}
public Rectangle()
{
  this(new Location(1,1), new Shape(100,100));
}
}

2、消除歧义：
class Location
{
private int x;
private int y;
public Location(int x,int y)
{
  this.x=x;
  this.y=y;
}
  ……
}

3、返回对象－链式方法调用：
public class Count
{
private int i = 0;
Count increment()
{
  i++;
  return this; //返回对象的地址，所以我们可以链式访问它
}
void print()
{
  Sop("i = " + i);
}
}
public class CountTest
{
p s v main(String[] args)
{
  Count x = new Count();
  x.increment().increment().print();
  }
}

4、作为参数传递"this”变量－进行回调:
假设有一个容器类和一个部件类，在容器类的某个方法中要创建部件类的实例对象，而部件类的构造方法要接受一个代表其所在容器的参数。例如：
class Container
{
Component comp;
public void addComponent()
  {
   comp = new Component(this);
//代表你所创建的对象，因为它要用到.
   }
}
class Component
{
Container myContainer;
public Component(Container c)
  {
    myContainer = c;
  }
}

慢慢的就会接触到更多更深入的应用的，加油加油，与楼主更勉之！！！

简单一些去想，要知道，在java中，如果一个类的（成员函数内部）所定义的一个变量的变量名与该类的一个成员变量的变量名相同，在方法内部直接使用变量名去访问这个变量时，访问到的将会是方法内部所定义的变量，而不是类的成员变量。再来看你的例子，你的例子中传递给构造函数的参数 s 相当于一个方法的内部变量，若直接用变量名去访问，访问到的将会是这个“内部变量”。若要访问外部的变量 s ，就需要使用this关键字，来表示访问的是这个HeimaThis对象中的变量 s ，而不是构造函数里面的变量 s