Javase易混点专项复习01_this关键字、super关键字

1.this关键字

1.1功能：

表示当前对象；
表示构造方法;

1.1.1表示当前对象

this可以用来指代当前对象，当成员变量和局部变量重名，可以用关键字this来区分。

1. 当方法参数与成员变量同名时，必须使用this明确指定访问的是成员变量。
   this点出来的一定是成员的变量
   哪个对象调用的this所在的方法,this就代表哪个对象

public class Student {
    private String name; // 成员变量
    
    public void setName(String name) { // 参数与成员变量同名
        this.name = name; // this.name指向成员变量
    }
}

1.1.2表示当前对象的内存解释：

public class Person {
    String name;

    /*
       哪个对象调用的this所在的方法,this就代表哪个对象
     */
    public void speak(String name){
        System.out.println(this+"........");
        System.out.println(this.name+"您好,我是"+name);
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person+"=========");
        person.name = "沉香";
        person.speak("刘彦昌");

        System.out.println("==========");

        Person person2 = new Person();
        System.out.println(person2+"+++++");
        person2.name = "奥特曼";
        person2.speak("奥特曼之父");
    }
}

public class Person {
    private String name;
    private int age;

    //为name提供get/set方法
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    //为age提供get/set方法
    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("因顺于");
        person.setAge(16);
        System.out.println(person.getName()+"..."+person.getAge());
    }
}

1.1.2 表示构造方法;

1. 调用本类其他构造方法
   通过this(参数)在构造方法中调用同一类的其他构造方法
   注意：this(参数)必须在构造方法的第一行。

public class ChangFangXing {
    private int width, height;
    
    public ChangFangXing() {
        this(10, 10); // 调用全参构造方法
    }
    
    public RChangFangXing(int width, int height) {
        this.width = width;
        this.height = height;
    }
}

2.super关键字

功能和this类似，也有两大类：

1. 代表父类对象
2. 代表父类构造方法

2.1 代表父类对象

在子类中，可直接访问从父类继承到的属性和方法，但如果父子类的属性或方法存在重名（属性遮蔽、方法重写）时，需要加以区分，才可访问到父类中的属性或方法。

public class Dog extends Animal {
    private String color;//毛色

    //跑
    public void run() {
        System.out.println("run...");
    }

    //子类重写父类中的方法，方法名称、参数列表、返回值类型必须与父类相同。
    @Override
    public void eat() {
        super.eat();
        System.out.println("狗吃骨头...");
    }
}

super关键字可在子类中访问父类的方法。

使用super.的形式访问父类的方法，进而完成在子类中的复用，叠加额外的功能代码，组成新的功能。
父子类的同名属性不存在重写关系，两块空间同时存在（子类遮蔽父类属性），需使用不同前缀进行访问。

public class A {
    int value = 10;
}

public class B extends A {
    int value = 20; //子类属性遮蔽父类属性

    public void print() {
        int value = 30;

        System.out.println(value); //访问局部变量
        System.out.println(this.value); //访问本类的属性
        System.out.println(super.value); //访问父类的属性
    }
}

public class MyTest2 {
    public static void main(String[] args) {
        B b = new B();
        b.print();//分别输出30、20、10
    }
}

2.2代表父类构造方法

2.2.1 继承中对象创建（熟悉此例子方便2.2.2理解代表父类构造方法部分）

在具有继承关系的对象创建中，构建子类对象会先构建父类对象。

由父类的共性内容，叠加子类的独有内容，组成完整的子类对象。

public class X {
    public X() {
        System.out.println("X的构造方法...");
    }
}

public class Y {
    public Y() {
        System.out.println("Y的构造方法...");
    }
}

public class A {
	private X x = new X();
    
    public A() {
        System.out.println("A的构造方法...");
    }
}

public class B extends A {
    private Y y = new Y();
    
    public B() {
        System.out.println("B的构造方法...");
    }
}

public class C extends B {
    public C() {
        System.out.println("C的构造方法...");
    }    
}

public class MyTest3 {
    public static void main(String[] args) {
        C c = new C();
    }
}

构建过程：
A类
默认构建父类对象Object；
初始化A的属性；
执行A的构造方法代码。
B类
构建父类对象A；
初始化B的属性；
执行B的构造方法代码。
C类
构建父类对象B；
初始化C的属性；
执行C的构造方法代码。

输出如下：

X的构造方法...
A的构造方法...
Y的构造方法...
B的构造方法...
C的构造方法...

2.2.2代表父类构造方法

super()：表示调用父类无参构造方法，如果没有显式书写，隐式存在于子类构造方法的首行。

public class A {
	private X x = new X();
    
    public A() {
        System.out.println("A的构造方法...");
    }
}

public class B extends A {
    private Y y = new Y();
    
    public B() {
        //super(); //默认存在
        System.out.println("B的构造方法...");
    }
}

public class C extends B {
    public C() {
        //super(); //默认存在
        System.out.println("C的构造方法...");
    }    
}

super(参数…)：表示调用父类有参构造方法。

public class A {
	private X x = new X();
    
    public A() {
        System.out.println("A的构造方法...");
    }
    
    public A(int value) {
        System.out.println("A的构造方法..." + value);
    }
}

public class B extends A {
    private Y y = new Y();
    
    public B() {
        //super(); //默认存在
        System.out.println("B的构造方法...");
    }
    
    public B(int value) {
        super(value);
        System.out.println("B的构造方法..." + value);
    }
}

public class MyTest4 {
    public static void main(String[] args) {
        B b = new B(100);
    }
}

输出：

X的构造方法...
A的构造方法...100
Y的构造方法...
B的构造方法...100

注意！！！！！
this或super使用在构造方法中时，都要求在首行。
当子类构造中使用了this()或this(参数)，就不可再同时书写super()或super(参数)，会由this()指向的构造方法完成super()的调用。

重点理解下面的例子
理解this（）怎么调用

public class A {
    private X x = new X();

    public A() {
        System.out.println("A的无参构造...");
    }

    public A(int value) {
        System.out.println("A的有参构造..." + value);
    }
}

public class B extends A {
    private Y y = new Y();

    public B() {
        super();
        System.out.println("B的无参方法...");
    }

    public B(int value) {
        this();
        System.out.println("B的有参方法..." + value);
    }
}

public class MyTest5 {
    public static void main(String[] args) {
        B b = new B(100);
    }
}

输出：

X的构造方法...
A的无参构造...
Y的构造方法...
B的无参方法...
B的有参方法...100

super总结：
两种用法：

在子类方法中使用super.的形式访问父类的属性和方法；
在子类的构造方法的首行，使用super()或super(参数)，调用父类构造方法。
注意：

如果子类构造方法中，没有显式定义super()或super(参数)，则默认提供super();
同一个子类构造方法中，super()、this()不可同时存在。