Detailed explanation of the loading order of classes in Java

This article introduces the loading sequence of classes in Java. Let’s take a look at the detailed introduction:

1. When the virtual machine loads a Java class for the first time, it will Static initialization blocks, static member variables, and static methods are initialized once

2. An instance of the class will only be created when the new method is called

3. Class instance creation process: Initialization is carried out according to the parent-child inheritance relationship. First, execute the initialization block part of the parent class, then the construction method of the parent class; then execute the initialization block of the subclass inherited by this class. Finally, there is the construction method of the subclass

4. When the class instance is destroyed, first destroy the subclass part, and then destroy the parent class part

Example

public class Parent
{
 public static int t = parentStaticMethod2();
 {
 System.out.println("父类非静态初始化块");
 }
 static
 {
 System.out.println("父类静态初始化块");
 }
 public Parent()
 {
 System.out.println("父类的构造方法");
 }
 public static int parentStaticMethod()
 {
 System.out.println("父类类的静态方法");
 return 10;
 }
 public static int parentStaticMethod2()
 {
 System.out.println("父类的静态方法2");
 return 9;
 }
 
 @Override
 protected void finalize() throws Throwable
 {
 // TODO Auto-generated method stub
 super.finalize();
 System.out.println("销毁父类");
 }
 
}
public class Child extends Parent
{
 {
 System.out.println("子类非静态初始化块");
 }
 static
 {
 System.out.println("子类静态初始化块");
 }
 public Child()
 {
 System.out.println("子类的构造方法");
 }
 public static int childStaticMethod()
 {
 System.out.println("子类的静态方法");
 return 1000;
 }
 @Override
 protected void finalize() throws Throwable
 {
 // TODO Auto-generated method stub
 super.finalize();
 System.out.println("销毁子类");
 }
}
public class Test
{
 
 public static void main(String[] args)
 {
 // TODO Auto-generated method stub
 Parent.parentStaticMethod();
// Child child = new Child();
 
 }

}

Output

父类的静态方法2
父类静态初始化块
父类类的静态方法

The static method in the class is loaded when it is called for the first time, and the static members in the class are loaded in the class Loaded in the order they appear. Output when calling static method 2

父类的静态方法2
父类静态初始化块
父类的静态方法2

Comment out Parent.parentStaticMethod();

Remove the comment Child child = new Child();

父类的静态方法2
父类静态初始化块
子类静态初始化块
父类非静态初始化块
父类的构造方法
子类非静态初始化块
子类的构造方法

Summary

The above is the entire content of this article. I hope the content of this article can bring some benefits to everyone’s study or work. For help, if you have any questions, you can leave a message to communicate.

For more detailed articles on the loading order of classes in Java, please pay attention to the PHP Chinese website!