java静态/动态成员变量、初始化块，父类/子类构造函数执行顺序问题

1. /*
2. * 几大原则
3. * 1、静态成员变量（Static）
4. * 一、静态成员变量为类变量，全部对象共享同一内存空间
5. * 二、静态成员变量的声明和定义仅在首次加载类时执行一次
6. * 三、首次加载类时首先对全部静态成员变量根据类型默认赋初值，而后再对有右值的附右值
7. * 2、静态初始块
8. * 一、静态初始化块仅在首次加载类时执行一次
9. * ······多个静态成员变量与静态始化快参照出现顺序前后执行······
10. * 3、动态成员变量
11. * 一、动态成员变量定义在每次实例化对象时在构造函数以前执行
12. * 4、动态初始化块
13. * 一、动态初始化块在每次实例化对象时在构造函数以前执行
14. * ······多个动态成员变量与动态初始化块参照出现顺序前后执行······
15. * 总结：总的来讲，在不涉及继承的前提下，当首次加载类时，按照以下顺序执行
16. * 一、按照出现顺序前后执行静态成员变量定义与静态初始化块
17. * 二、按照出现顺序前后执行动态成员变量定义与动态初始化块
18. * 三、执行构造函数
19. * 再次实例化对象时只执行第二、3步便可
20. *
21. * ············成员变量与定义与初始化块先于构造函数执行·········
22. * 5、当涉及到继承时，按照以下顺序执行
23. * 一、执行父类的静态成员变量定义与静态初始化块，执行子类的静态成员变量定义与静态初始化块
24. * 二、执行父类的非静态成员变量定义与动态初始化块，执行父类构造方法
25. * 三、执行子类的非静态成员变量定义与动态初始化块，执行子类构造方法
26. * 另：父类构造方法中用到的方法若是已被子类重写，那么在构造子类对象时在调用父类构造函数中使用子类重写的方法
27. */

1.实例变量和类变量的内存分配

类变量 ：使用static修饰的成员变量是类变量，属于该类自己

实例变量：没有使用static修饰的成员变量是实例变量，属于该类的实例

因为同一个JVM内每一个类只对应一个Class对象，所以同一个JVM内的一个类的类变量只需一块内存空间。

对于实例变量而言，该类每建立一次实例，就须要为实例变量分配一块内存空间，因此，程序中有几个实例，实例变量就须要几块内存空间。

2.类变量的初始化时机老是处于实例变量的初始化以前

咱们先看下下面三段代码：

1）由于两个实例变量都是在建立变量的时候才开始分配空间，此时num2尚未分配，因此前向引用就会出现编译错误。

1 int num = num2 + 3; //非法前向引用,会报错 2 int num2 = 2

2）由于两个类变量在JVM加载类的时候分配空间，此时num2尚未分配，因此前向引用就出现编译错误。

1 static int num = num2 + 3; //非法前向引用,会报错 2 static int num2 = 2

3）由于类变量num2在JVM加载类的时候空间已经分配好，而num在建立实例的时候才分配空间，此时num2已经分配成功了，因此num前向引用成功。

1 int num = num2 + 3; //正确使用 2 static int num2 = 2;

由上面三段代码块就能够验证得：类变量的初始化时机老是处于实例变量的初始化以前

3.Java对象的初始化方式及其执行顺序

Java对象的初始化方式有三种：1）构造器 2）初始化块 3）定义变量时指定初始化值

若是这三种初始化方式同时出现，也要注意，他们也有一个执行顺序的规定：

1）静态初始化块只在类第一次建立对象的时候运行一次，后面就不会再运行，而类在每次建立对象时，非静态初始化块老是会运行一次。

public class Test{
    static {
        System.out.println("执行---静态初始化代码块.");
    }
    
    {
        System.out.println("执行---非静态初始化代码块.");
    }
    
    public static void main(String[] args) {
        for (int i = 1; i <= 2; i++) {
            System.out.println("建立第 " + i + " 个对象"); 
            new Test();
            System.out.println();
        }
    }
}

运行结果：

2）构造器每次建立对象时，构造器必然有执行的机会，此时，非静态初始化块一定也将得到机会而且运行在构造器以前

public class Test{

    {
        System.out.println("执行---非静态初始化代码块.");
    }
    
    public Test() {
        System.out.println("执行---构造器.");
    }
    
    public static void main(String[] args) {
        for (int i = 1; i <= 2; i++) {
            System.out.println("建立第 " + i + " 个对象"); 
            new Test();
            System.out.println();
        }
    }
}

运行结果:

3）定义变量时指定的初始化值和初始化块中指定的初始值的执行顺序与他们在源程序中的排列顺序相同。

验证代码一：

public class Test{
    
    String i = "定义变量时指定的初始化值";

    {
        i = "初始化块中指定的初始值";
    }
    
    public static void main(String[] args) {
        for (int i = 1; i <= 2; i++) {
            System.out.println("建立第 " + i + " 个对象"); 
            System.out.println(new Test().i);
            System.out.println();
        }
    }
}

运行结果

验证代码二 ：

public class Test{

    {
        i = "初始化块中指定的初始值";
    }
    
    String i = "定义变量时指定的初始化值";

    public static void main(String[] args) {
        for (int i = 1; i <= 2; i++) {
            System.out.println("建立第 " + i + " 个对象"); 
            System.out.println(new Test().i);
            System.out.println();
        }
    }
}

运行结果：

4.关于父子实例的内存控制

（通常状况下是不用内部类来验证的，可是都是同样的啦，我偷懒下，因此使用了内部类，你们原谅哈）

1）当子类重写父类方法后，父类表面上只是调用属于本身的被子类重写的方法。

public class Test{
    class Base {
        Base() {
            this.info();
        }
        public void info() {
            System.out.println("Base");
        }
        public void getInfo() {
            info();
        }
    }
    
    public class Child extends Base{
        @Override
        public void info() {
            System.out.println("Child");
        }
    }
    
    public static void main(String[] args) {
        Test test = new Test();
        Base base = test.new Child();
        base.info();
        base.getInfo();
    }
}

运行结果：

2）上述是属于多态中方法的体现，可是方法有多态，实例变量无多态。

解释下“方法有多态，变量无多态”这句话：意思是，无论怎样，父类表面上只是调用属于本身的被子类重写的方法。而变量不同，假设父类和子类都有同一个变量名的实例变量，向上转型后，经过父类访问的实例变量获得的值是自身的而非子类的。向下转型后，经过子类访问的实例变量获得的值是自身的而非父类的。

不少书上或教学视频上都讲，建立一个子类对象的时候，Java 会顺着继承结构往上一直找到 Object，而后从 Object 开始往下依次执行构造函数。先执行父类的构造函数，而后在其子类中会建立一个成员变量指向他的父类。其实这个说法是错误的，系统并不会真正的去建立父类对象，只是在子类对象中不只保存了自己的实例变量，还有它父类的所有实例变量。

public class Test{
    class Base {    //父类
        int i = 2;
    }
    
    public class Child extends Base{    //子类
        int i  = 20;
    }
    
    public static void main(String[] args) {
        Test test = new Test();
        Child child = test.new Child();
        Base base = child;
        System.out.println(" Base.i : " + base.i);
        System.out.println("Child.i : " + child.i);
    }
}

运行结果：

5.final修饰符

final变量在编译时就被肯定下来了，至关于一个直接量。

1）final修饰的实例变量赋值时机：

• 定义final实例变量时 指定初始值　
• 在非静态初始化模块中为final实例变量指定的初始值
• 在构造器中为final实例变量指定初始值　　　

2）final修饰的类变量赋值时机：　

• 定义final类变量时指定初始值
• 在静态初始化模块中为final实例变量指定的初始值