Java中的关键字this_super

要点

1.在类的构造器中，可以使用 this() 调用本类的其它构造器，调用的时候根据构造器声明的参数列表传递参数值

2.super() 调用父类的无参构造器

3.super.method() 调用父类的 method() 方法

4.super.name 访问父类的变量 name

5.使用 this() 和 super() 调用构造器，必须写在构造方法体内，且必须写在第一个语句中

6.this() 和 super() 不可以同时存在构造方法体内

错误的理解

1.this 表示当前对象

2.this 表示当前对象中的本类的资源

3.super 表示当前对象中继承自父类的资源

4.this 就是一个局部变量，保存当前对象的引用地址

正确的理解

1.this 表示本类的含义 2.super 表示父类的含义

演示代码

类 Ape：

package priv.lwx.javaprac.lambda;

public class Ape {
    String bloodColor;
    String name;
    String skinColor;
    private int age;

    public String getBloodColor() {
        return bloodColor; // 会编译成Ape$bloodColor
    }

    public String getName() {
        return this.name; // 会编译成Ape$name
    }
}

类 Person：

package priv.lwx.javaprac.lambda;

public class Person extends Ape {
    static String gender = "pp";
}

类 WhitePerson：

package priv.lwx.javaprac.lambda;

public class WhitePerson extends Person {
    private int age;
    private String name;
    public WhitePerson() {

    }

    public WhitePerson(String name, int age, String bloodColor) {
        this.name = name;
        this.age = age;
        this.bloodColor = bloodColor;
    }

    public WhitePerson(String name, int age, String bloodColor, String skinColor,String gender) {
        this.age = age;
        this.name = name; // 会编译成WhitePerson$name
        this.bloodColor = bloodColor; // 会编译成Ape$bloodColor
        super.skinColor = skinColor; // 会编译成Ape$skinColor
        this.gender = gender; // 会编译成Person.gender
    }

    public WhitePerson(String name, int age, String bloodColor, String skinColor) {
        this.age = age;
        this.name = name;
        this.bloodColor = bloodColor; // 会编译成Ape$bloodColor
        super.skinColor = skinColor; // 会编译成Ape$skinColor
        this.gender = gender; // 会编译成Person.gender，值为"pp"
    }

    public int getAge() {
        return age;
    }

    public String getBloodColor() {
        return this.bloodColor; // 会编译成 return Ape$bloodColor
    }

}

演示类 Demo02WhitePerson：

package priv.lwx.javaprac.lambda;

public class Demo02WhitePerson {
    public static void main(String[] args) {
        WhitePerson whitePerson1 = new WhitePerson("西太隆", 38, "red", "white");

        String gender = whitePerson1.gender; // 会编译成Person.gender
        System.out.println(gender); // 值为"pp"
        String name = whitePerson1.getName(); // whitePerson1对象中存在两个名为name的变量,分别是Ape$name、WhitePerson$name，方法getName返回的是当前对象中Ape$name的值
        System.out.println(name); // null

        String bloodColor = whitePerson1.getBloodColor();
        System.out.println(bloodColor); // red

        WhitePerson whitePerson2 = new WhitePerson("喜太郎", 28, "blue", "yellow", "male");
        String gender1 = whitePerson2.gender; // 会编译成Person.gender
        System.out.println(gender1); // male


    }
}

举例说明：

假设构造方法中有这句代码 this.name = name，等号左边部分 this.name 在编译时，编译器会在本类 WhitePerson.java 中查找是否存在变量 name，如果存在还会继续判断是不是静态的变量，如果是静态的变量会编译成 WhitePerson.name 这样的语法格式；如果不是静态的变量，则会编译成 WhitePerson$name 这样的语法格式，表示这个变量 name 是来自于类 WhitePerson。

如果本类 WhitePerson 中找不到变量 name，则会往上查找，如果找到顶层的父类还是找不到，则会报编译错误。假设在父类 Person 中找到了变量 name，同样会判断是不是静态的变量，如果是则会编译成 Person.name 这样的语法格式；如果不是静态的变量，则会编译成 Person$name 这样的语法格式，表示这个变量 name 是来自于类 Person。

假设最后编译成 Person$name = name 这样的语法格式，那么在运行时，JVM 会去当前对象中查找来自于类 Person 的变量 name，再将参数 name 的值赋值给变量 Person$name

假设构造方法中有这句代码 super.name = name，等号左边部分 super.name 在编译时，编译器会在父类 Person.java 中查找是否存在变量 name，如果存在会继续判断是不是静态的变量，如果是静态的变量则会编译成 Person.name 这样的语法格式；如果不是静态的变量，则会编译成 Person$name 这样的语法格式，表示这个变量 name 是来自于类 Person。

同样地，如果父类 Person 中找不到变量 name，也会往上查找，如果找到顶层的父类还是找不到，则会报编译错误。假设在 Person.java 的父类 Ape.java 中找到了变量 name，接着判断该变量是不是静态的，如果是静态的则会编译成 Ape.name；如果不是静态的，则会编译成 Ape$name，表示变量 name 来自于类 Ape。

假设最后编译成 Ape$name = name 这样的语法格式，那么在运行时，JVM 会去当前对象中查找来自于类 Ape 的变量 name，再将参数 name 的值赋值给变量 Ape$name。