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) {
        new Hello("HelloWorld!");
    }
}

运行结果：

s = HelloWorld!
1 -> this.s = Hello
2 -> this.s = HelloWorld!

在这个例子中，构造函数A中，参数s与类A的变量s同名，这时如果直接对s进行操作则是对参数s进行操作。若要对类A的变量s进行操作就应该用this进行引用。运行结果的第一行就是直接对参数s进行打印结果；后面两行分别是对对象A的变量s进行操作前后的打印结果。

public class Leaf {
    private int i = 0;
    Leaf increment() {
        i++;
        return this;
    }
    void print() {
        System.out.println("i = " + i);
    }
    public static void main(String[] args) {
        Leaf x = new Leaf();
        x.increment().increment().increment().print();
    }
}

 

2. 把this作为参数传递。

当你要把自己作为参数传递给别的对象时，也可以用this。

class A{
    //A的构造函数，创建了一个匿名的对象B，B的构造函数的参数是A的实例，然后调用B的print方法
    public A(){
        new B(this).print();
    }
    public void print(){
        System.out.println("Hello from A");
    }
}

class B{
    A a; //在B类中声明了一个A类型变量a

    public B(A a){ //B的构造函数，参数是A
        this.a = a; //将参数a传递给B对象中的a变量
    }
    public void print(){
        a.print(); //调用了B对象中的a变量的print方法
        System.out.println("Hello from B");
    }
}

public class ThisUse{
    public static void main(String[] args){
        new A(); //创建一个匿名的A类对象
    }
}

运行结果：
Hello from A!
Hello from B!

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

3. 注意匿名类和内部类中的中的this。

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

public class InnerThis {
   int i = 1;

   public InnerThis() {
      Thread thread = new Thread() {
         public void run() {
            for(;;) {
                InnerThis.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 InnerThis();
   }
}

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

4. 在构造函数中，通过this可以调用同一class中别的构造函数。

public class Flower {
    private int petalCount = 0;
    private String s = new String("null");
    
    Flower(int petals) {
        petalCount = petals;
        System.out.println("Constructor w/ int arg only, petalCount= "+ petalCount);
    }
    
    Flower(String ss) {
        System.out.println("Constructor w/ String arg only, s=" + ss);
        s = ss;
    }
    
    Flower(String s,int petals) {
        this(petals);
        //! this(s); // Can't call two!
        this.s = s; // Another use of "this"
        System.out.println("String & int args");
    }
    
    Flower() {
        this("hi", 47);
        System.out.println("default constructor (no args)");
    }

    void print() {
        //! this(11); // Not inside non-constructor!
        System.out.println("petalCount = " + petalCount + " s = " + s);
    }

    public static void main(String[] args) {
        Flower x = new Flower();
        x.print();
    }
}

1) 在构造调用另一个构造函数，调用动作必须置于最起始的位置。

2) 不能在构造函数以外的任何函数内调用构造函数。

3) 在一个构造函数内只能调用一个构造函数。