Java 子类实例化演示 - 继承、构造方法和成员变量 - 常规

该 Java 代码定义了三个类：A、B 和 C，它们之间存在继承关系：C 继承自 B，B 继承自 A。每个类都包含构造方法、成员变量和方法。

在主类 SubClassInstanceDemo 中，创建了一个 C 类的对象 c 并打印了 c 对象的 k 成员变量。

代码运行过程如下：

创建 C 类的对象 c 时，先调用 C 类的构造方法。
在 C 类的构造方法中，首先调用了 C 类的重载构造方法 C(double d)。
在 C(double d) 的构造方法中，打印了 'C(double d) 的构造方法'。
然后返回到 C 类的构造方法中，打印了 'C 的构造方法, k=3'。
在 C 类的构造方法中，先调用了 C 类的 f2() 方法。
在 f2() 方法中，打印了 'C 的方法 f2(), f=false'，并返回了 3。
返回到 C 类的构造方法中，将返回值 3 赋给了成员变量 k。
最后打印了 c 对象的 k 成员变量，输出为 3。

注意：

在类 A 中，成员变量 i 的初始化使用了 f() 方法，而该方法中又引用了 i，所以 i 的初始值为 0。
类 B 和类 C 中的成员变量 j 和 k 的初始化同理。

代码示例：

package test;

public class A {
    private int i = f();

    public A() {
        System.out.println('A 的构造方法, i=' + i);
    }

    public int f() {
        System.out.println('A 的方法 f(), i=' + i);
        return 1;
    }
}

class B extends A {
    private int j = f1();

    public B() {
        System.out.println('B 的构造方法, j=' + j);
    }

    public int f1() {
        System.out.println('B 的方法 f1(), j=' + j);
        return 2;
    }
}

class C extends B {
    boolean f;
    int k = f2();

    public C() {
        this(3.4);
        System.out.println('C 的构造方法, k=' + k);
    }

    public C(double d) {
        System.out.println('C(double d) 的构造方法');
    }

    public int f2() {
        System.out.println('C 的方法 f2(), f=' + f);
        return 3;
    }
}

public class SubClassInstanceDemo {
    public static void main(String[] args) {
        C c = new C();
        System.out.println(c.k);
    }
}

代码分析：

继承： 类 B 继承自类 A，类 C 继承自类 B，体现了面向对象编程中的继承特性。
构造方法： 每个类都定义了构造方法，用于初始化对象。
成员变量： 每个类都包含成员变量，用于存储对象的状态。
方法调用顺序： 子类实例化时，会先调用父类的构造方法，再调用子类的构造方法。
成员变量初始化： 成员变量的初始化顺序取决于其声明的位置，先声明的先初始化。