java中的this

Question

我对this的用法很是模糊，在网上搜到了下面的材料，哪位大侠给我讲解下2和3怎么走，因为我是刚开始学这个，说的越基础越好，谢谢各位大侠。
java中的this随处可见，用法也多，现在整理有几点：
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!"); 
     } 
 }
 
 
运行结果： 
 s = HelloWorld! 
 1 -> this.s = Hello 
 2 -> this.s = HelloWorld!
 
在这个例子中，构造函数Hello中，参数s与类Hello的变量s同名，这时如果直接对s进行操作则是对参数s进行操作。若要对类Hello的成员变量s进行操作就应该用this进行引用。运行结果的第一行就是直接对构造函数中传递过来的参数s进行打印结果； 第二行是对成员变量s的打印；第三行是先对成员变量s赋传过来的参数s值后再打印，所以结果是HelloWorld!
2. 把this作为参数传递 
当你要把自己作为参数传递给别的对象时，也可以用this。如： 
  public class A { 
    public A() { 
     new B(this).print(); 
   } 
 
    public void print() { 
     System.out.println("Hello from A!"); 
   } 
 } 
 
  public class B { 
   A a; 
    public B(A a) { 
     this.a = a; 
   } 
 
    public void print() { 
     a.print(); 
     System.out.println("Hello from B!"); 
   } 
 } 
 
 运行结果： 
   Hello from A! 
   Hello from B! 
 
 
在这个例子中，对象A的构造函数中，用new B(this)把对象A自己作为参数传递给了对象B的构造函数。 
 
3. 注意匿名类和内部类中的中的this。 
有时候，我们会用到一些内部类和匿名类，如事件处理。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。如下面这个例子： 
  public class A { 
     int i = 1; 
 
      public A() { 
          Thread thread = new Thread() { 
              public void run() { 
                  for(;;) { 
                     A.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 A(); 
     }
 } 
 在上面这个例子中, thread 是一个匿名类对象，在它的定义中，它的 run 函数里用到了外部类的 run 函数。这时由于函数同名，直接调用就不行了。这时有两种办法，一种就是把外部的 run 函数换一个名字，但这种办法对于一个开发到中途的应用来说是不可取的。那么就可以用这个例子中的办法用外部类的类名加上 this 引用来说明要调用的是外部类的方法 run。 
 
4。在构造函数中，通过this可以调用同一class中别的构造函数，如
  public class Flower{ 
             Flower (int petals){} 
             Flower(String ss){} 
             Flower(int petals, Sting ss){ 
                 //petals++;调用另一个构造函数的语句必须在最起始的位置 
                 this(petals); 
                //this(ss);会产生错误，因为在一个构造函数中只能调用一个构造函数 
            } 
 } 
 
值得注意的是：
1：在构造调用另一个构造函数，调用动作必须置于最起始的位置。
2：不能在构造函数以外的任何函数内调用构造函数。
3：在一个构造函数内只能调用一个构造函数。

Answer 1

2 的程序从 A类开始走，
首先，走A的构造public A() ，
new B(this).print(); 
是实例化B的一个对象，走B的构造方法，并且把对象A作为参数传送过去，
然后走B的print()方法。
此时的变量a,已经被初始化
走B的print方法体
a.print(); 
System.out.println("Hello from B!");结果就是：
Hello from A! 
Hello from B!

Answer 2

3 的程序执行
首先 main 方法
new A(); 执行
走构造方法
public A() { 
  Thread thread = new Thread() {   //实例化一个线程对象
    public void run() {            //重写java.lang.Thread 的 public void run() 方法
      for(;;) {                    //循环
        A.this.run();              //走类A的run方法，打印i
        try { 
        sleep(1000);               //停止1000毫秒，重新执行Thread 的run方法
        } catch(InterruptedException ie) {    } 
      } 
    } 
  }; //注意这里有; 
   thread.start();                 //启动线程
} 这个例子里用到了线程，如果没有接触过就不用多想 ，就认为他是一个延时操作就行
A.this.run();执行的是A类中的run方法，而不是线程的run方法。

Answer 3

多谢楼上，
main中B b = new B(new A());
楼上讲解的很明了。

Answer 4

看看我的blog吧
这个专门讲过
http://blog.csdn.net/terryzero

Answer 5

2. 把this作为参数传递 
当你要把自己作为参数传递给别的对象时，也可以用this。如： 
  public class A { 
    public A() { 
    new B(this).print(); 
  }     public void print() { 
    System.out.println("Hello from A!"); 
  } 
}   public class B { 
  A a; 
    public B(A a) { 
    this.a = a; 
  }     public void print() { 
    a.print(); 
    System.out.println("Hello from B!"); 
  } 
} 运行结果： 
  Hello from A! 
  Hello from B!
public class Test{
public static void main(String args[]){
A test=new A();
}
}
运行Test类，进入main方法，要new一个A类的对象，这时进入了类A的构造方法；A的构造方法中要new一个B类的对象，并调用B类中的print方法；先看B类的构造方法，因为B类的构造方法要传入一个A类的对象，所以利用了this关键字传入了当前的A类的对象，进入了B的构造方法，在B类中有一个属性是A类的引用(即A a)，B的构造方法利用传入的参数给a赋值，但恰好参数名与属性名相同，故而采用this关键字来区分this.a 红色即为属性 而a蓝色为传入的参数。至此B类的构造方法结束，回到A类的构造方法中的new B(this).print(); 一句；要调用B中print方法，进入B的print方法体内，先调用A类中的print方法，进入A的print方法体内，打印“Hello from A”退出A的print方法，
返回B的print方法中的  System.out.println("Hello from B!"); 一句，打印“Hello from B”退出B的print方法，返回到A的构造方法中，至此A的构造方法执行完毕，返回Test类的main方法，程序结束。
3. 注意匿名类和内部类中的中的this。 
有时候，我们会用到一些内部类和匿名类，如事件处理。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。如下面这个例子： 
  public class A { 
    int i = 1;       public A() { 
          Thread thread = new Thread() { 
              public void run() { 
                  for(;;) { 
                    A.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 A(); 
    } 
} 
在上面这个例子中, thread 是一个匿名类对象，在它的定义中，它的 run 函数里用到了外部类的 run 函数。这时由于函数同名，直接调用就不行了。这时有两种办法，一种就是把外部的 run 函数换一个名字，但这种办法对于一个开发到中途的应用来说是不可取的。那么就可以用这个例子中的办法用外部类的类名加上 this 引用来说明要调用的是外部类的方法 run。
这个类也没有什么可解释的，因为是涉及到匿名内部类的知识，如果是初学者，建议把匿名内部类看懂了再来看这个类，那就很好理解了，A.this.run(); 这一句是在写匿名内部类里面的，只写this不在前面加A. 的话会让JVM认为是匿名内部类的this对象。

Answer 6

派特森英语新春特惠啦！！！买一年赠一年！
今年过年不收礼，收礼只收：英语课
--金融危机以来，最实用和时尚的新年礼物！春节前加入派特森大家庭的同学，享受买一年赠一年的特惠活动
活动说明：
1、 凡在1月25日前报名的学员，均享受买一年赠一年的优惠；
2、 一人购买，两人受益：所赠送课程，您可以作为新年礼物赠送给您的亲朋好友。他们可以在新年过后，再来学校开课学习；
3、 特惠VIP课程：您只要一次购买20节或以上课程，均享受买一节赠一节的优惠。快快行动，年终奖金花在哪里？投资未来从现在开始！
网站：www.bjpattison.com
联系人：孙老师13810327391