this与super关键字总结

　Ⅰ.this

　　用类名定义一个变量的时候，定义的应该只是一个引用，外面可以通过这个引用来访问这个类里面的属性和方法。类里面也有一个引用来访问自己的属性和方法，这个引用就是 this 对象，它可以在类里面来引用这个类的属性和方法。

　　每当一个对象创建后，Java虚拟机会给这个对象分配一个引用自身的指针，这个指针的名字就是 this。因此，this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this的用法。

　　this主要要三种用法：

1. 　　在类的方法定义中使用的this关键字代表调用该方法对象的引用。（this关键字只能在方法内部使用；只有当需要明确指出当前对象的引用时，才使用this关键字）
2. 　　表示用类的成员变量，而非函数参数，注意在函数参数和成员变量同名是进行区分！其实这是第一种用法的特例，比较常用，所以拿出来强调一下。
3. 　　将当前的对象传递给其他方法。
4. 　　用于在构造方法中引用满足指定参数类型的构造器（其实也就是构造方法）。但是这里必须非常注意：只能引用一个构造方法且必须位于开始！

示例程序：

eg1

public class ThisDemo {  
    int number = 0;
    ThisDemo increment(){
         number++;
         return this;
    }  
  private void print(){
         System.out.println("number="+number);
    }
    public static void main(String[] args) {
        ThisDemo tt=new ThisDemo();
         tt.increment().increment().increment().print();
    }
}
/*Output:
i = 3
*///:~

可以看到，通过this关键字可以很容易在一条语句里面对同一个对象执行多次操作。

eg2 将当前的对象传递给其他方法

//: initialization/PassingThis.java

class Person {
  public void eat(Apple apple) {
    Apple peeled = apple.getPeeled();
    System.out.println("Yummy");
  }
}

class Peeler {
  static Apple peel(Apple apple) {
    // ... remove peel
    return apple; // Peeled
  }
}

class Apple {
  Apple getPeeled() { return Peeler.peel(this); }
}

public class PassingThis {
  public static void main(String[] args) {
    new Person().eat(new Apple());
  }
} /* Output:
Yummy
*///:~

Apple需要调用Peeler.peel()方法，它是一个外部的工具方法，将执行由于某种原因而必须放在Apple外部的操作。为了将其自身传递给外部方法，Apple必须使用this关键字。

eg3 在构造方法中引用满足指定参数类型的构造器

//: initialization/Flower.java
// Calling constructors with "this"
import static net.mindview.util.Print.*;

public class Flower {
  int petalCount = 0;
  String s = "initial value";
  Flower(int petals) {
    petalCount = petals;
    print("Constructor w/ int arg only, petalCount= "
      + petalCount);
  }
  Flower(String ss) {
    print("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" 参数s和数据成员s的名字相同，用this.s来避免歧义。
    print("String & int args");
  }
  Flower() {
    this("hi", 47);
    print("default constructor (no args)");
  }
  void printPetalCount() {
//! this(11); // Not inside non-constructor!
    print("petalCount = " + petalCount + " s = "+ s);
  }
  public static void main(String[] args) {
    Flower x = new Flower();
    x.printPetalCount();
  }
} /* Output:
Constructor w/ int arg only, petalCount= 47
String & int args
default constructor (no args)
petalCount = 47 s = hi
*///:~

构造器Flower(String s, int petals)表明：尽管可以用this调用一个构造器，但却不能调用两个。此外，必须将构造器调用置于最起始位置处，否则编译器会报错。

printPetalCount()方法表明，除构造器之外，编译器禁止在其他任何方法中调用构造器。

　Ⅱ.super

　　super的使用和this基本相同，现在写下两者之间的比较：

　　1.super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。

　　2.this和super不能同时出现在一个构造函数里面。

　　3.super()和this()均需放在构造方法内第一行。

　　4.this()和super()都指的是对象，所以，均不可以在static环境中使用。

另外1.在构造器中this或super必须放在第一行　

　　必须在构造器的第一行放置super或者this构造器，否则编译器会自动地放一个空参数的super构造器的，其他的构造器也可以调用super或者this，调用成一个递归构造链，最后的结果是父类的构造器（可能有多级父类构造器）始终在子类的构造器之前执行，递归的调用父类构造器。无法执行当前的类的构造器。也就不能实例化任何对象，这个类就成为一个无为类。

 　　从另外一面说，子类是从父类继承而来，继承了父类的属性和方法，如果在子类中先不完成父类的成员的初始化，则子类无法使用，应为在java中不允许调用没初始化的成员。在构造器中是顺序执行的，也就是说必须在第一行进行父类的初始化。而super能直接完成这个功能。This()通过调用本类中的其他构造器也能完成这个功能。因此，this()或者super()必须放在第一行。

 

另外2（static的含义）

　　了解this关键字之后，就能更全面的理解static方法的含义。static方法没有this的方法。在static方法的内部不能调用非静态方法，但反过来可以。可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。但这实际上正是static方法的主要用途。Java中禁止使用全局方法，但通过在类中置入static方法就可以访问其他static方法和static域。