How to implement instance initialization and static initialization in Java

#Java code initialization block is a very important concept in the Java language. When an object is created, the initialization block is responsible for performing some necessary operations, such as setting the initial state of the object and initializing member variables. Initialization blocks are divided into two types: instance initialization blocks and static initialization blocks.

The instance initialization block is executed when the object is created and will be executed every time a new object is created. Used to perform operations required when an object is created, such as initializing instance variables, this is the instance initialization block. Here is an example:

public class Example {
    private int var1;
    private String var2;

    // 实例初始化块
    {
        var1 = 10;
        var2 = "Hello, world!";
    }

    public Example() {
        System.out.println("Constructor");
    }
}

We define an Example class and add an instance initialization block in it, as shown below. When we create the Example object, the instance initialization block is executed to set the initial values ​​of var1 and var2.

The static initialization block of a class is executed only once when the class is loaded and before the class constructor is called. The initialization of static variables can be achieved through a static initialization block when the class is loaded, which is used to perform related operations. The following is an example:

public class Example {
    private static int var1;
    private static String var2;

    // 静态初始化块
    static {
        var1 = 20;
        var2 = "Goodbye, world!";
    }

    public static void main(String[] args) {
        System.out.println(var1);
        System.out.println(var2);
    }
}

We defined an Example class in the above code and added a static initialization block. When we run the main method in the Example class, the static initialization block is executed and used to set the initial values ​​of var1 and var2.

Instance initialization blocks and static initialization blocks are very important concepts in Java. They can be used to perform some necessary operations, such as initializing variables, preprocessing, etc. Below we will introduce the process of instance initialization and static initialization in detail.

1. Instance initialization

The instance initialization block is executed when creating an object and will be executed every time a new object is created. In a class, we can use instance initialization blocks to assign initial values ​​to instance variables.

1.1 Instance initialization process

The following is an example showing the execution process of the instance initialization block:

public class Example {
    private int var1;
    private String var2;

    // 实例初始化块
    {
        var1 = 10;
        var2 = "Hello, world!";
    }

    public Example() {
        System.out.println("Constructor");
    }

    public static void main(String[] args) {
        Example e = new Example();
    }
}

We created an Example class in the above code snippet, and An instance initialization block is added to it. In the main method, we create an Example object. The instance initialization block will be executed when the object is created and is used to set the initial values ​​​​of var1 and var2.

1.2 The order of instance initialization

After all operations in the constructor, the execution order of the instance initialization block is before it. The following is an example showing the execution sequence of instance initialization blocks and constructors:

public class Example {
    private int var1;
    private String var2;

    // 实例初始化块
    {
        System.out.println("Instance Initialization Block");
        var1 = 10;
        var2 = "Hello, world!";
    }

    public Example() {
        System.out.println("Constructor");
    }

    public static void main(String[] args) {
        Example e = new Example();
    }
}

We define an Example class in the above code and add an instance initialization block and a constructor. In the main method, we create an Example object.

When we execute the program, we will find that the output of the instance initialization block is before the constructor. This proves that the instance initialization block is indeed executed before the constructor.

1.3 Notes on instance initialization

In the instance initialization block, we can access instance variables. However, accessing static variables or methods within an instance initialization block is not allowed. Static variables or methods can be referenced by their class name in an instance initialization block.

2. Static initialization

The static initialization block is executed when the class is loaded and only executed once. Its execution precedes the call of the class constructor. In a class, we can use static initialization blocks to assign initial values ​​to static variables.

2.1 Static initialization process

The following is an example showing the execution process of the static initialization block:

public class Example {
    private static int var1;
    private static String var2;

    // 静态初始化块
    static {
        var1 = 20;
        var2 = "Goodbye, world!";
    }

    public static void main(String[] args) {
        System.out.println(var1);
        System.out.println(var2);
    }
}

We define an Example class and add a static initialization to it block, at the top of the code. In the main method, we output the values ​​​​of var1 and var2.

When we run the program, we will find that the output of the static initialization block occurs before the main method. This proves that the static initialization block is indeed executed when the class is loaded.

2.2 The order of static initialization

The order in which they appear in the code determines the initialization order of static initialization blocks and static variables. Here is an example showing the initialization sequence of static initialization blocks and static variables:

public class Example {
    private static int var1 = 10;
    private static String var2;

    // 静态初始化块
    static {
        System.out.println("Static Initialization Block");
        var2 = "Hello, world!";
    }

    public static void main(String[] args) {
        System.out.println(var1);
        System.out.println(var2);
    }
}

In the above code we have declared a class named Example and added a static variable and a static initialization block in it . In the main method, we output the values ​​​​of var1 and var2.

We will notice that the output of the static initialization block will not be executed until the static variables are initialized. This proves that the static initialization block is indeed executed after the static variables are initialized.

2.3 Notes on static initialization

In the static initialization block, we can access static variables and methods. However, accessing instance variables or methods within a static initialization block is not allowed. In order to use instance variables or methods, we can create an object reference and put it in a static initialization block.

The above is the detailed content of How to implement instance initialization and static initialization in Java. For more information, please follow other related articles on the PHP Chinese website!