How to initialize classes and objects in Java

First, let’s take a look at the following code. This is a very classic way of inspection.

public class InitField {      public static void main(String[] args) {          SuperInitField p = new SuperInitField();          SuperInitField c = new SubInitField();      }  }   class SuperInitField {      public SuperInitField() {          System.out.println("parent");      }      static {          System.out.println("static parent");      }   }   class SubInitField extends SuperInitField {      public SubInitField() {          System.out.println("child");      }      static {          System.out.println("static child");      }  }

Regardless of whether you can write the correct answer quickly or not, let's put this program aside first and understand the principle of Java virtual machine initialization.

The JVM installs, connects and initializes a Java type so that the type can be used by the running Java program. The life cycle of the type is shown in the figure below:

Loading and connection must be completed before initialization.

The class initialization phase is mainly to assign correct initial values ​​to class variables. The "correct" initial value here refers to the starting value that the programmer expects this class variable to have. A correct initial value is given through a class variable initialization statement or a static initialization statement. Initializing a class involves two steps:

1) If the class has a direct superclass, and the direct superclass has not been initialized, initialize the direct superclass first.

2) If the class has a class initialization method, execute this method.

When will the class be initialized? The Java virtual machine specification strictly defines the initialization timing of a class: initialized when it is actively used.

So what situations meet the criteria for active use by ***? The Java Virtual Machine Specification explains this, they are:

1) Create a new instance of the class;

2) Call the static method of the class;

3) Manipulate static fields of classes or interfaces (except final fields);

4) Call specific reflection methods of Java;

5) Initialize a subclass of a class;

6) Specify a class as the initialization class when the Java virtual machine starts.

Except for the above six situations, all other methods are used passively and will not cause class initialization.

Once a class is loaded, connected, and initialized, it is ready for use. Now let's focus on the instantiation of objects. Object instantiation and initialization are activities in the initial stage of the object's life.

The Java compiler generates at least one instance initialization method for each class it compiles, namely the () method. Each class constructor in the source code has a corresponding () method. If the class does not explicitly declare any constructor, the compiler generates a default no-argument constructor for the class. This default constructor only calls the parent class's no-argument constructor.

There may be three types of code content included in an () method: calling another () method; initializing instance variables; and constructing the method body code.
If the constructor explicitly starts by calling another constructor in the same class, the content included in its corresponding () method body is:

1. A call to the () method of this class;

2. implements the bytecode of the method body corresponding to the construction method.

If the construction method does not start by calling other construction methods of its own class, and the object is not an Object object, then the content included in the () method is:

1. A call to the() method of a parent class;

2. The bytecode of any instance variable initialization method;

3. Implements the bytecode of the method body corresponding to the construction method.

Does the above explanation help you understand the initialization of Java types?

Okay, let’s analyze the beginning of the code again:

SuperInitField p = new SuperInitField();  //SuperInitField的超类是Object  //创建SuperInitField对象，属于***主动使用，因此要先初始化Object类，然后再调用SuperInitField类变量初始化语句或者静态初始化语句，所以要输出static parent  //类被装载、连接和初始化之后，创建一个对象，因此需要首先调用了Object的默认构造方法，然后再调用自己的构造方法，所以要输出parent    SuperInitField c = new SubInitField();  //SubInitField继承自SuperInitField  //创建SubInitField对象，属于***主动使用，父类SuperInitField已被初始化，因此只要调用SubInitField类变量初始化语句或者静态初始化语句，所以要输出static child  //类被装载、连接和初始化之后，创建一个对象，因此需要首先调用了SuperInitField的构造方法，然后再调用自己的构造方法，所以要输出parent，然后再输出child

By now you should have a general understanding of the principles of Java class initialization, so I’ll leave it to the practice questions. , write the results of the following code.

public class Test {      public Test(){          System.out.println("parent");      }      static{          System.out.println("static parent");      }      public static void main(String[] args) {          System.out.println("main");      }  }

The above is the detailed content of How to initialize classes and objects in Java. For more information, please follow other related articles on the PHP Chinese website!