this.super/有继承关系的构造执行顺序

在继承多态中：
1、对于方法的覆盖，new的谁就调谁，这就是多态。

2、对于成员变量的覆盖，this在哪个类就指向哪个类的成员变量，没有多态。

/**
 * @author Mr.Gao
 * @version 1.0
 * @date 2021/4/8 11:29
 */
class A{
    int a=1;
    public void a1(){
        System.out.println(1);
    }

    public A( ) {
        System.out.println("A构造");

    }
}

class B extends A{
    public B( ) {

        System.out.println("B中构造执行");
    }

    int b=2;
    public void b1(){
        System.out.println(2);
    }
}

class C extends B{
    int c=3;

    public C( ) {
        System.out.println("C中构造");
    }

    public void c1(){
        System.out.println(3);
    }
}

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


}

执行有继承关系的代码：先会加载最上层父类的属性和构造方法a,A()。再依次下沉，执行对应的属性初始化b，和构造方法B()。直到最后C类中初始化属性c,和构造方法C（）。

super();--------->隐藏于子类构造中，（调用父类无参构造）
super(实参);---------->调用父类有参构造。
this();------>用于构造方法中时，会调用当前类的无参构造。
this.属性/方法-------->表示当前类。

/**
 * @author Mr.Gao
 * @version 1.0
 * @date 2021/5/8 16:32
 */
public class Test1 {
    public static void main(String[] args) {
        B b = new B();
        b.upload();
    }
}
class A{
    public A() {
        System.out.println("A构造");
    }

    public void upload(){
        System.out.println("A upload方法执行");
    }
}
class B extends A{
    public B() {
        System.out.println("B构造");
    }

    public void upload(){
        System.out.println("B upload方法执行");
    }
}

/**
 * @author Mr.Gao
 * @version 1.0
 * @date 2021/5/8 9:20
 */
public class Demo {
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.num);//这里定义的是父类，而成员变量没有多态，所以即使你new的子类，依然指向父类的成员变量。
        System.out.println(f.fun1());//不解释了，就是多态。
        f.show();
    }
}

class Fu {
    static {
        System.out.println("父静态 块");
    }
    public String num = "父类成员变量";

    public Fu() {
        System.out.println("父亲无参构造");
    }

    public void show() {
        System.out.println(this.num);//因为成员变量没有多态，所以this指向当前类对象的成员变量。
        System.out.println(this.fun1());//因为方法有多态，所以this指向new对象的方法。
    }

    public String fun1() {
        System.out.println(this.num);//因为成员变量没有多态，所以this指向当前类对象的成员变量。
        return "父类调用";
    }
}

class Zi extends Fu {
    static {
        System.out.println("子 静态代码块");
    }

    public String num = "子类成员变量";

    public Zi() {
        System.out.println("子类无参构造");
    }

    public String fun1() {
        System.out.println(this.num);//因为成员变量没有多态，所以this指向当前类对象的成员变量。
        return "子类调用";
    }
}