this和super的共同点和不同点？？有点混有点乱。。

1)super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）  

2)this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）
3)super:　它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名    super.成员函数据名（实参）

4)this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）

5）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。

6）super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。

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

8）尽管可以用this调用一个构造器，但却不能调用两个。

9）this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。

10）this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。

11）从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

1．什么是super？什么是this？
　　super关键字表示父类的意思。this变量代表对象本身。

2．使用super,this调用成员变量和方法

　　可以使用super访问父类被子类隐藏的变量或覆盖的方法。当前类如果是从超类继承而来的，当调用super.XX()就是调用基类版本的XX（）方法。

　　示例1
class Person {
　　protected void print() {
　　　 System.out.println("The print() in class Person.");
　　}
}
public class SuperDemo extends Person {
　　public void print() {
　　　 System.out.println("The print() in class DemoSuper.");
　　　 super.print();// 调用父类的方法
　　}
　　public static void main(String[] args) {
　　　 DemoSuper ds = new DemoSuper();
　　　 ds.print();
　　}
}

　　结果：

The print() in class SuperDemo.
The print() in class Person.

　　当类中有两个同名变量，一个属于类（类的成员变量），而另一个属于某个特定的方法（方法中的局部变量），使用this区分成员变量和局部变量。

　　示例2

public class ThisDemo {
　　private String name;
　　public void setName(String name) {
　　　 this.name = name;// 前一个name是private name；后一个name是setName中的参数。
　　}
}

this表示当前对象，也就是当前类对象，super表示当前类的父类。

举例：你定义一个新的类：A,这个A继承了类B,也就是说B是A的父类。那么如果A中 有个方法：aa();B中也有个方法： aa();

那么在A 中用this.aa()调用的就是A中定义的方法，而super.aa()调用的就是A的父类B中定义的方法aa();

this关键字
1)在类的内部代表对象本身，你应该看到过this.xxx(),this.xxx这种用法吧，
this就代表这个类的对象，比如
public class A {
   private String name;
   public void setName(String name) {
       //this就代表A的一个对象
       //当你实例一个A时,A a1 = new A();this就是那个a1，只是this在内部用，而a1在外部用
       //A a2 = new A()同理，这时在a2的内部，this就代表a2
       this.name = name;
   }
}

2)this的第二种用法，是用在构造函数里的
当在构造器里要调用自己的其他构造器时，就用this
this必须放在第一行
public class A {
   private String name;
   public A() {
       this("no name");
   }

   public A(String name) {
       this.name = name;
       //other codes
   }
}


super关键字
1)显式的调用父类的方法
当从一个类继承时，子类和父类都有一个同名方法，也就是子类覆盖了父类的方法，可是又想调用父类的方法，那么就要用super，像继承swing的类时就有个好例子
public class MyPanel extends JPanel {
   @Override
   public void paint(Graphics g) {
       super.paint(g);//如果不用super，那么就会调用自己的paint方法
   }
}

2）用在构造器，和this的用法一样，super也可以用在构造器，this是调用自己的其他构造器，那么super当然就是调用父类的构造器了
-------------------------------------------------------

super和this用在构造器的话，前者表示调用父类的够早器，后者表示调用本类的其他构造器，他们两个都必须是写在构造器里的第一行

public class Person {
   private String name;
   private int age;
   public Person() {
       name = "";
       age = 0;
   }

   public Person(String n, int a) {
       name = n;
       age = a;
   }
}

public class Student extends Person {
   private String id;//学号

   public Student(String name, int age) {
       super(name, age);//必须写在第一行，子类无法直接访问父类的私有属性，所以通过调用父类的构造器类初始化属性
   }

   public Student(String id, String name, int age) {
       this(name, age);//因为本类已经有个构造器初始化name和age了，所以交给他来做就行了，也必须写在第一行
       this.id = id;
   }
}
这个例子够清晰了吧

关键字this： 是直接访问本类中的内容；this.本类属性，调用本类中的属性；this.本类方法(),可以不写this,也表示调用本类的；this 是访问本类中的其他构造，必须放在首行。

       关键字super： 是由子类访问父类的内容；super.父类属性，如果属性没有被覆写，则也可以不写super；super.父类方法(),如果方法没有被覆写，则可以不用 加super也表示调用父类中的方法；super是访问父类中的构造方法，必须放在首行。


  eg：
this
public class Person {
String name;
int age;
public String getName() {
  return name;
}
public void setName(String name) {
  this.name = name;                                                                                             
                                                     //this访问的是本类中的内容
}
public int getAge() {
  return age;
}
public void setAge(int age) {
  this.age = age;
}
//这里我们定义一个说话的方法
void say()
{

  System.out.println("姓名："+name+",年龄："+age);
}
}


super
class Student extends Person{
  //如果此处任何内容都不写，则至少应该与Person类的内容一致
public Student(String name,int age,String school){
  super(name,age);                                                                                            
                                                        //super访问的是父类Person中的内容
  this.setSchool(school);
  System.out.println("*****子类的构造方法****");
}
private String school;
public void setSchool(String school){
  this.school=school;
}
  public String getSchool()
     {
             return this.school;
     }
public void fun(){
  setName("zhijun");
  setAge(21);
}
public void print(){
  System.out.println(getlnfo()+"，学校："+school);
}
}

this：在类的方法定义中，使用“this”关键字代表使用该方法的对象和引用变量。
在定义时，“this”指向哪个对象，自己并不知道，哪个对象调用该方法，“this”就指向哪个对象。
*this可以用来解决成员变量和局部变量重名的情况;
*this(参数列表)调用本类中其他重载的构造方法,它必须在构造方法的第一句;

super：当子类覆盖了从父类继承的方法或变量时，在子类范围内，父类的方法和变量是不可见的，
在这种情况下，如果使用父类中的方法或变量就要使用super关键字，
使用形式是：super.成员变量名或方法名(参数)。
super(参数列表)用来显示的调用父类的构造方法。

this是对本类对象的引用
super是对父类对象的引用

1. this表示当前对象的引用：用法this.method(); this.field;
    this()方法表示在本类构造器中调用本类其他构造器，可以传参数：用法this(); this(参数...);只能出现在构造器的第一句。

2. super表示父类对象的引用：用法super.method(); super.field;(有访问权限才行)
    super()方法表示在本类构造器中调用父类构造器，可以传参数：用法super(); super(参数...);只能出现在构造器的第一句。

3.相同点：this和super都表示对象的引用。本类对象和父类对象，所以，均不可以在static环境中使用。
    this()方法和super()方法都只能出现在构造器的第一句。（不写则隐式为super();）

4.区别：this指本类对象的引用；super指父类对象的引用
    this()方法调用的是本类的构造器；super()方法调用的是父类构造器。

简单的说，this就是对本类对象的引用，super是对父类对象的引用

"this"的用法
构造器和方法使用关键字this有很大的区别。方法引用this指向正在执行方法的类的实例。静态方法不能使用this关键字，因为静态方法不属于类的实例，所以this也就没有什麽东西去指向。构造器的this指向同一个类中，不同参数列表的另外一个构造器，我们看看下面的代码：

public class Platypus {

String name;

Platypus(String input) {
name = input;
}

Platypus() {
this("John/Mary Doe");
}

public static void main(String args[]) {
Platypus p1 = new Platypus("digger");
Platypus p2 = new Platypus();
}
}

在上面的代码中，有2个不同参数列表的构造器。第一个构造器，给类的成员name赋值，第二个构造器，调用第一个构造器，给成员变量name一个初始值 "John/Mary Doe".

在构造器中，如果要使用关键字this,那麽，必须放在第一行，如果不这样，将导致一个编译错误。

"super"的用法
构造器和方法，都用关键字super指向父类，但是用的方法不一样。方法用这个关键字去执行被重载的超类中的方法。看下面的例子：

class Mammal {
void getBirthInfo() {
System.out.println("born alive.");
}
}

class Platypus extends Mammal {
void getBirthInfo() {
System.out.println("hatch from eggs");
System.out.print("a mammal normally is ");
super.getBirthInfo();
}
}

在上面的例子中，使用super.getBirthInfo()去调用超类Mammal中被重载的方法。

构造器使用super去调用超类中的构造器。而且这行代码必须放在第一行，否则编译将出错。看下面的例子：

public class SuperClassDemo {
SuperClassDemo() {}
}

class Child extends SuperClassDemo {
Child() {
super();
}
}

在上面这个没有什麽实际意义的例子中，构造器 Child()包含了 super,它的作用就是将超类中的构造器SuperClassDemo实例化，幷加到 Child类中。

编译器自动加入代码
编译器自动加入代码到构造器，对于这个，java程序员新手可能比较混淆。当我们写一个没有构造器的类，编译的时候，编译器会自动加上一个不带参数的构造器，例如：public class Example {}
编译后将如下代码：

public class Example {
Example() {}
}


在构造器的第一行，没有使用super，那麽编译器也会自动加上，例如：

public class TestConstructors {
TestConstructors() {}
}

编译器会加上代码，如下：

public class TestConstructors {
TestConstructors() {
super;
}
}

仔细想一下，就知道下面的代码

public class Example {}

经过会被编译器加代码形如：

public class Example {
Example() {
super;
}
}

简单的说：
this是对本类对象的引用
super是对父类对象的引用

super：对父类对象的引用
this：当前对象的引用
super()和this()均需放在构造方法内第一行
this()和super()不能同时出现在一个构造函数里面