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域。