anonymous的Java学习笔记(13)——Java面向对象之初始化块(静态代码块与代码块)

初始化块(静态代码块与代码块)

Java使用构造器来对单个对象进行初始化操作,使用构造器先完成整个Java对象的状态初始化,
然后将Java对象返回给程序,从而让该Java对象的信息更加完整。

与构造器作用非常类似的是初始化块,它也可以对Java对象进行初始化操作。

使用初始化块

初始化块语法格式

[修饰符] {
    //初始化块的可执行代码
    ...
}
  • 初始化块的修饰符只能是static,使用static修饰的初始化块被称为静态初始化块。
  • 初始化块里的代码可以包含任何可执行性语句,包括定义局部变量、调用其他对象的方法,以及使用分支、循环语句等。

代码示例

package com.abc.part4;

/**
 * @Auther: ABC
 * @Date: 2020/5/14 23:32
 * @Description:
 */
public class Person3 {
    //定义一个初始化块
    {
        int a = 6;
        if (a > 4) {
            System.out.println("Person3初始化块:局部变量a的值大于4");
        }
        System.out.println("Person3的初始化块。");
    }

    //定义第二个初始化块
    {
        System.out.println("Person3的第二个初始化块。");
    }

    //定义无参构造器
    public Person3() {
        System.out.println("Person3类的无参构造器。");
    }

    public static void main(String[] args) {
        new Person3();
    }
    /**
     * 输出:
     * Person3初始化块:局部变量a的值大于4
     * Person3的初始化块。
     * Person3的第二个初始化块。
     * Person3类的无参构造器。
     */
}
  • 从运行结果可以看出,当创建Java对象时,系统总是先调用该类里定义的初始化块。
  • 如果一个类里定义了2个普通初始化块,则前面定义的初始化块先执行,后面定义的初始化块后执行。
  • 初始化块无法通过类、对象来调用。初始化块只在创建Java对象时隐式执行,而且在执行构造器之前执行。所以完全可以把多个普通初始化块合并成1个初始化块,从而可以让程序更加简洁,可读性更强。

初始化块和构造器之间的区别

从某种程度上来看,初始化块是构造器的补充,初始化块总是在构造器执行之前执行。系统同样可使用初始化块来进行对象的初始化操作。

与构造器不同的是,初始化块是一段固定执行的代码,它不能接收任何参数,因此初始化块对同一个类的所有对象所进行的初始化处理完全相同。

基于以上原因引出初始化块的作用

  • 如果有一段初始化处理代码对所有对象完全相同,且无须接收任何参数,就可以把这段初始化处理代码提取到初始化块中。
  • 把两个构造器中的代码提取成初始化块示意图。
    初始化块

从上图可以看出

  • 如果两个构造器中有相同的初始化代码,且这些初始化代码无须接收参数,就可以把它们放在初始化块中定义。
  • 通过把多个构造器中的相同代码提取到初始化块中定义,能更好地提高初始化代码的复用,提高整个应用的可维护性。

需要注意的点

实际上初始化块是一个假象,使用Javac命令编译Java类后,该Java类中的初始化块会消失———初始化块中代码会被"还原"到每个构造器中,且位于构造器所有代码的前面。

普通初始化块和构造器的加载过程

创建Java对象时,不仅会执行该类的普通初始化块和构造器,而且系统会一直上溯到java.lang.Object类,先执行java.lang.Object类的初始化块,开始执行java.lang.Object的构造器,依次向下执行其父类的初始化块,开始执行其父类的构造器……最后才执行该类的初始化块和构造器,返回该类的对象。

静态初始化块

定义初始化块时使用了static修饰符,则这个初始化块就变成了静态初始化块,也被称为类初始化块(普通初始化块负责对对象执行初始化类初始化块则负责对类进行初始化)。

  • 静态初始化块是类相关的,系统将在类初始化阶段执行静态初始化块,而不是在创建对象时才执行。
  • 静态初始化块总是比普通初始化块先执行。
  • 静态初始化块相关的,用于对整个进行初始化处理,通常用于对类变量执行初始化处理。静态初始化块不能对实例变量进行初始化处理。
  • 静态初始化块也被称为类初始化块,也属于类的静态成员,同样需要遵循静态成员不能访问非静态成员的规则,因此静态初始化块不能访问非静态成员,包括不能访问实例变量实例方法

静态初始化块的加载过程

与普通初始化块类似的是,系统在类初始化阶段执行静态初始化块时,不仅会执行本类的静态初始化块,而且还会一直上溯到java.lang.Object类(如果它包含静态初始化块),先执行java.lang.Object类的静态初始化块(如果有),然后执行其父类的静态初始化块……最后才执行该类的静态初始化块,经过这个过程,才完成了该类的初始化过程。只有当类初始化完成后,才可以在系统中使用这个类,包括访问这个类的类方法、类变量或者用这个类来创建实例。

代码示例
package com.abc.part4;

/**
 * @Auther: ABC
 * @Date: 2020/5/15 00:16
 * @Description:
 */
public class Root {
    static {
        System.out.println("Root类的静态初始化块");
    }

    {
        System.out.println("Root类的普通初始化块");
    }

    public Root() {
        System.out.println("Root类的无参构造器");
    }
}
package com.abc.part4;

/**
 * @Auther: ABC
 * @Date: 2020/5/15 00:17
 * @Description:
 */
public class Mid extends Root {
    static {
        System.out.println("Mid类的静态初始化块");
    }

    {
        System.out.println("Mid类的普通初始化块");
    }

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

    public Mid(String msg) {
        //通过this调用本类中重载的构造器
        this();
        System.out.println("Mid类的带参构造器,参数值为" + msg);
    }
}
package com.abc.part4;

/**
 * @Auther: ABC
 * @Date: 2020/5/15 00:21
 * @Description:
 */
public class Leaf extends Mid {
    static {
        System.out.println("Leaf类的静态初始化块");
    }

    {
        System.out.println("Leaf类的普通初始化块");
    }

    public Leaf() {
        //通过super调用父类中有一个字符串参数的构造器
        super("哈哈哈");
        System.out.println("执行Leaf类中的构造器");
    }
}
package com.abc.part4;

/**
 * @Auther: ABC
 * @Date: 2020/5/15 00:23
 * @Description:
 */
public class Test {
    public static void main(String[] args) {
        new Leaf();
        System.out.println("****************分割线****************");
        new Leaf();
    }
}

以上类的继承结构
继承结构

执行Test.java中的main方法时,类与对象的加载过程.

类与对象加载过程

  1. 第一次创建Leaf对象时,因为系统中还不存在Leaf类,因此需要先加载并初始化Leaf类,初始化Leaf类时会先执行其顶层父类的静态初始化块,再执行其直接父类的静态初始化块,最后才执行Leaf本身的静态初始化块。
  2. Leaf类初始化成功后,Leaf类在该虚拟机里将一直存在,因此当第二创建Leaf实例时无须再次对Leaf类进行初始化。
  3. 普通初始化块和构造器的执行顺序与前面介绍的一致,每次创建一个Leaf对象时,都需要先执行最顶层父类的初始化块、构造器,然后执行其父类的初始化块、构造器……最后才执行Leaf类的初始化块和构造器。

Java系统加载并初始化某个类时,总是保证该类的所有父类(包括直接父类和间接义类)全部加载并初始化。

补充知识点

静态初始化块和声明静态成员变量时所指定的初始值都是该类的初始化代码,它们的执行顺序与源程序中的排列顺序相同。

代码示例
package com.abc.part4;

/**
 * @Auther: ABC
 * @Date: 2020/5/15 00:52
 * @Description:
 */
public class StaticInitTest {
    //先执行静态初始化代码块,将a的值赋值为6
    static {
        a = 6;
    }
    //再将a静态成员变量赋值为9
    static int a = 9;


    public static void main(String[] args) {
        //下面代码将输出9
        System.out.println(StaticInitTest.a);
    }
}

上面程序中定义了两次对a静态成员变量进行赋值,执行结果是a值为9,这表明static int a = 9;这行代码位于静态初始化块之后执行。

如果将上面程序中静态初始化块static int a = 9;调换顺序,将可以看到程序输出6,这是由于静态初始化块中代码再次将a的值设为6

得到的结论

当JVM第一次主动使用某个类时,系统会在类准备阶段为该类的所有静态成员变量分配内存;在初始化阶段则负责初始化这些静态成员变量,初始化静态成员变量就是执行类初始化代码或者声明类成员变量时指定的初始值它们的执行顺序与源代码中的排列顺序相同。