Detailed description of the order of initialization and execution of static members, static code blocks, ordinary members, ordinary code blocks, and constructor methods of Java classes

Today I read "JavaProgrammingThoughts (4th Chinese Edition)", and I just reviewed the knowledge point of initialization of members in a class. In order to deepen the impression and give others a reference, refer to the examples in the book and modify them to get the following code:

File name: HelloWorld.java

Package name: main

package main;
class Bowl {
    Bowl(int marker){
        System.out.println("Bowl("+marker+")");
    }
    void f1(int marker){
        System.out.println("f1("+marker+")");
    }
}
class Table{
    static Bowl bowl1 = new Bowl(1); 
    public Table() {
        System.out.println("Table()");
        bowl2.f1(1);
    }
    void f2 (int marker){
        System.out.println("f2("+marker+")");
    }
    static Bowl bowl2 = new Bowl(2); 
}
class Cupboard{
    {
        System.out.println("Cupboard类普通代码块执行");
    }
    Bowl bowl3 = new Bowl(3); // 注意，此处不是静态成员
    static Bowl bowl4 = new Bowl(4);
    static{
        System.out.println("Cupboard类静态代码块执行");
    }
    public Cupboard() {
        // TODO Auto-generated constructor stub
        System.out.println("Cupboard()");
        bowl4.f1(2);
    }
    void f3(int marker){
        System.out.println("f3("+marker+")");
    }
    static Bowl bowl5 = new Bowl(5);
}
public class HelloWorld  {
   public static void main(String args[]){
       System.out.println("Creating new Cupboard() in main");
       new Cupboard();
       table.f2(1);
       cupboard.f3(1);
   }
   static Table table = new Table();
   static Cupboard cupboard = new Cupboard();
}

Let us analyze the operation of this program.

1. First, if the Java virtual machine wants to execute the main method, it must first load the class HelloWorld

2. It is found that the class HelloWorld contains static data (only static members) and starts to initialize the static members
First
【1】 static Table table = new Table(); So the Table class needs to be loaded. It is found that the class contains static members, and the initialization operations are performed according to the defined sequence
[2] static Bowl bowl1 = new Bowl(1); Output: Bowl(1)
[3] static Bowl bowl2 = new Bowl( 2); Output: Bowl(2)
[4]ConstructorTable(), output: Table() and f1(1)

Second
[1] static Cupboard cupboard = new Cupboard(); So the Cupboard class needs to be loaded. It is found that this class contains static data (including static members and static code blocks), and the initialization operation is performed according to the order defined by the two.
[2] static Bowl bowl4 = new Bowl(4); Output: Bowl(4)
【3】
　static{
　　System.out.println("Cupboard class static code block execution");
　　}
Output: Cupboard class static code block execution
【4】 static Bowl bowl5 = new Bowl(5); Output: Bowl(5)
After the static members are initialized, objects are generated through new. It is found that the class contains member definition assignment and ordinary code blocks, and the initialization operation is performed according to the order in which they are defined
【1】
　　{
　　System.out.println("Cupboard class ordinary code block execution" );
　　}
　Output: Cupboard class ordinary code block execution
【2】 Bowl bowl3 = new Bowl(3); Output: Bowl(3)
【3】Constructor Cupboard(), Output: Cupboard() and f1(2)

3. Enter the main method
【1】 System.out.println("Creating new Cupboard() in main"); Output: Creating new Cupboard( ) in main
【2】 new Cupboard(); It is found that the Cupboard class contains member definition assignment and ordinary code blocks. The initialization operation is performed according to the order in which they are defined. The output is: Cupboard class ordinary code block execution and Bowl( 3)
【3】Constructor Cupboard(), output: Cupboard() and f1(2)
【4】 table.f2(1); Output: f2(1)
【5】 cupboard .f3(1); Output: f3(1)
To sum up, the output result of the program is:
Bowl(1)
Bowl(2)
Table()
f1 (1)
Bowl(4)
Cupboard class static code block execution
Bowl(5)
Cupboard class ordinary code block execution
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main
Cupboard class ordinary code block execution
Bowl(3)
Cupboard()
f1(2)
f2(1 )
f3(1)

The initialization of Java class data is summarized as follows:

1. Static members and static code blocks are initialized in the order defined

　Here One thing to note is that the prerequisite for static code execution is that the Java virtual machine must first load this class, and static data will only be initialized once. The class is loaded when an object of a class is generated for the first time or when static data members belonging to the class are accessed for the first time.

2. Value assignments at ordinary member definitions and ordinary code blocks are initialized in the order of definition

3. Finally, constructor methodinitialization

The above is the detailed content of Detailed description of the order of initialization and execution of static members, static code blocks, ordinary members, ordinary code blocks, and constructor methods of Java classes. For more information, please follow other related articles on the PHP Chinese website!