Java-this、super关键字（认真分析）

一、this关键字

　　this关键字只能用于方法体内，当创建一个对象时候，JVM就会为这个对象分配一个资深的指针，就是this。因此this只能在非静态方法中使用，静态方法和静态的代码块中绝对不能使用this，this只和特定的对象关联，不和类关联，同一个类的不同对象有不同的this。

举个栗子：

package cn.zpoor.Test;
/**
 * @author 薛定谔的猫
 * 测试this*/
public class Main {
    private String name;
    private int age;
    private String sex;
    private int i = 33;
    //一个参数的构造器
    public Main(int n) {
        age = n;//可以写成this.age = age;
    }
    
    //带有两个参数的构造器
    public Main(int age,String name,String sex) {
        //成员变量和参数同名，成员变量被屏蔽，用this来访问成员变量
        this.name = name;
        this.sex = sex;
    }
    
    //默认构造器
    public Main() {
        this(0, null, null);//this调用另一个构造方法，并且只能放在第一行。
    }
    
    public Main(String name) {
        this(0, name, "man");
    }
    
    
    private void info(Main m) {
        System.out.println("-------------");
        System.out.println(m.name);
        System.out.println(m.age);
        System.out.println(m.sex);
        this.f();//写可以写成this.f();
    }
    
    private void f() {
        //局部变量和成员变量相同，成员变量被屏蔽，用this来访问成员变量
        int i;
        i = this.i++;
        System.out.println(i);
        System.out.println(this.i);
    }
    
    //返回当前实例的引用
    
    private Main getSelf() {
        return this;
    }
    
    
    public static void main(String[] args) {
        Main m1 = new Main();
        Main m2 = new Main("zpoor");
        m1.info(m1);
        m2.info(m2);
    }
}

/*-------------
null
0
null
33
34
-------------
zpoor
0
man
33
34

*/

不要慌（冷静分析）：

　　一、通过this调用另一个构造方法，this（参数列表），仅仅在构造函数，别的地方不能用，而且要放在构造方法中的第一行

　　二、方法的参数或者方法中的局部变量和成员变量重名的情况下，成员变量被屏蔽，就要用this.成员变量来引用成员变量。如果没有重名用不用都不为过。

　　三、在方法中，引用该方法所属类的当前对象时候，直接用this

总结：this是指向对象本身的一个指针。

二、super关键字

　　super和this类似，是被屏蔽的成员变量或者成员方法，或者是引用被屏蔽的成员变量和成员方法，一般都是发生在继承里面，super用在子类里面，用来访问父类中屏蔽的成员

举个栗子：

package cn.zpoor.Test;
/**
 * @author 薛定谔的猫
 * 测试super*/
public class Father {
    public String Value = "Father";
    public String x = "Father中的成员变量";
    
    public Father() {
        System.out.println("Father的构造器被调用");
    }
    
    public Father(String Value) {
        this.Value = "Father带参数的构造器运行了";
    }
    
    public void info() {
        System.out.println("Father的info方法被调用");
    }
    public static void main(String[] args) {
        new Son().test();
    }
}

class Son extends Father {
    public String Value = "Son";
    
    public Son() {
        super();//调用父类的构造方法，只能必须放在第一行
        System.out.println("Son的无参方法被调用");
    }
    
    public Son(String name) {
        super(name);
        System.out.println("Son带参数的构造器被调用");
    }
    
    //重写父类info方法
    public void info() {
        System.out.println("Son的info方法被调用");
    }
    
    public void test() {
        String Value = "老铁，得劲不？";//局部变量覆盖成员变量和超类成员变量
        System.out.println("-----1-----");
        System.out.println(Value);//输出局部变量Value
        System.out.println(this.Value);//输出子类成员变量
        System.out.println(super.Value);//输出父类的成员变量
        
        System.out.println("------2-----");
        System.out.println(x);//输出超类成员变量x，子类继承来的
        System.out.println(super.x);//输出曹磊成员变量x
        
        System.out.println("--------3------");
        info();//调用子类的info方法
        this.info();//调用子类的info方法
        super.info();//调用超类的info方法
    }
}

/*
Father的构造器被调用
Son的无参方法被调用
-----1-----
老铁，得劲不？
Son
Father
------2-----
Father中的成员变量
Father中的成员变量
--------3------
Son的info方法被调用
Son的info方法被调用
Father的info方法被调用
*/

总结（拿烟的手微微颤抖）：

　　一、子类构造方法要调用父类的构造方法，super（参数列表），参数不是必须的，但是放在第一行是一定的。

　　二、当子类的局部变量或者子类的局部变量和父类的成员变量重名，也就是子类变量覆盖父类变量的时候，super.成员变量来引用父类的成员变量，如果没有覆　盖，就不需要了，但是最好这样，这是一个好习惯。

　　三、当子类的成员方法覆盖了父类的成员方法，就是子类的方法定义和父类的方法相同（重写，覆盖），super.方法名（参数列表）来调用父类的成员变量。

不行了，烟烫手。