The initialization Object Sequence in Java, the usage of Static code blocks, and the usage of Static code blocks

The initialization Object Sequence in Java, the usage of Static code blocks, and the usage of Static code blocks

(1) differences between static methods for java static code blocks
Generally, if some code must be executed when the project is started, a static code block is required. This code is actively executed and needs to be initialized when the project is started, when other programs call an object without creating an object, a static method is required. Such code is passively executed. static methods can be called directly by class name when they are loaded.
For example, the main method must be static. This is the program entry.
The difference between the two is that static code blocks are automatically executed;
Static methods are executed only when they are called.

Static Method
(1) in Java, you can define a method that does not need to create an object. This method is a static method. To achieve this effect, you only need to add the static keyword before the method defined in the class. For example:

Public static int maximum (int n1, int n2)

Note the following when using static methods of the class:

A can only directly call other static members (including variables and methods) of the same type in the static method, but cannot directly call non-static members in the category. This is because for non-static methods and variables, you need to create an instance object for the class before use, and the static method does not need to create any objects before use.

The static method B cannot reference the this and super keywords in any way, because the static method does not need to create any instance objects before use. When the static method is called, the objects referenced by this are not generated at all.

(2) static variables belong to the entire class instead of an object. Note that the variables in any method body cannot be declared as static. For example:
Fun ()
{
Static int I = 0; // invalid.
}

(3) A class can use a static code block that is not included in any method body. When the class is loaded, the static code block is executed and only executed once, static blocks are often used to initialize class attributes. For example:
Static
{
}

Class loading steps
In Java, the Class Loader loads a class into a Java Virtual Machine. Three steps are required: Loading, linking, and initialization, the link can be divided into three steps: verification, preparation, and resolution. In addition to resolution, the other steps are completed in strict order. The main work of each step is as follows:

Load: Query and import binary data of classes or interfaces;
Link: perform the following verification, preparation, and resolution steps. The resolution steps are optional;
Verify: Check whether the binary data of the import class or interface is correct;
Preparation: allocate and initialize the storage space for static variables of the class;
Resolution: convert a symbolic reference to a direct reference;
Initialization: Initialize the Java code and static Java code block for activating static variables of the class.
Attributes in the initialization class are commonly used for static code blocks, but can only be used once.

(2) initialization sequence of static code blocks

Class Parent {static String name = "hello"; {System. out. println ("parent block");} static {System. out. println ("parent static block");} public Parent () {System. out. println ("parent constructor") ;}} class Child extends Parent {static String childName = "hello"; {System. out. println ("child block");} static {System. out. println ("child static block");} public Child () {System. out. println ("child constructor") ;}} public class StaticIniBlockOrderTest {public static void main (String [] args) {new Child (); // Statement (*)}}

Q: When the statement (*) is executed, what is the order of the printed results? Why?
A: When the statement (*) is executed, the result is printed in the following order:

parent static blockchild static blockparent blockparent constructorchild blockchild constructor

Analysis: when new Child () is executed, it first checks whether there is a static code block in the parent class. If yes, it first executes the content in the static code block in the parent class, after the content in the static code block of the parent class is executed, execute the static code block in the subclass (own class). After the static code block of the subclass is executed, it then checks whether the parent class has non-static code blocks. If yes, it executes non-static code blocks of the parent class. The non-static code blocks of the parent class are executed, and then the construction method of the parent class is executed; after the constructor of the parent class is executed, it goes on to check whether the Child class has non-static code blocks. If so, it executes the non-static code blocks of the Child class. After the non-static code block of the subclass is executed, the constructor of the subclass is executed. This is the initialization sequence of an object.

Summary:
Object initialization sequence: first, execute the static content of the parent class. After the static content of the parent class is executed, execute the static content of the Child class. After the static content of the Child class is executed, check whether the parent class has non-static code blocks. If yes, execute the non-static code blocks of the parent class. After the non-static code blocks of the parent class are executed, execute the construction method of the parent class; after the constructor of the parent class is executed, it goes on to check whether the Child class has non-static code blocks. If so, it executes the non-static code blocks of the Child class. The non-static code block of the subclass is executed before the subclass constructor is executed. In a word, the content of the static code block is first executed, followed by the non-static code block and constructor of the parent class, and then the non-static code block and constructor of the subclass are executed.

Note: No matter whether the constructor includes any parameter or not, the constructor of the subclass first searches for the constructor without parameters of the parent class. If the parent class does not have a constructor without parameters, the subclass must use the supper key child to call the constructor with parameters in the parent class. Otherwise, the compilation fails.