The class loading process in Java is fully resolved

The order in which class files are loaded

1. First load the static variables and static initializer blocks of the parent class (in the order of execution)

2. Reload the static variables and static initialization blocks that execute this class

As long as the class is not destroyed, static variables and static initializers are executed only once, and subsequent operations on the class do not perform these two steps.

Class instance creation process

An instance of the class is created only when the new method is called

1. Follow the order in which the class files are loaded (skip this step if the class has been loaded)

2. Non-static variables and non-static initialization blocks of the parent class

3. Constructor of the parent class

4. Non-static variables and non-static initialization blocks of this class

5. Constructor of this class

4, class instance destruction, first destroy the subclass part, then destroy the parent part

Both static and non-static methods are called passively

That is, the system does not automatically invoke execution. The main difference is that static methods can be called directly with the class name (as can instantiated objects), whereas non-static methods can only be called after instantiating the object.

Relevant concepts

Key words: static

Is a modifier used to modify members (member variables and member functions)

The modified member has the following characteristics:

Load as the class loads (when class 1 loads, static data immediately loads space in memory)

When a class disappears, it has the longest life cycle

Takes precedence over object existence (object disappears, static is still there)

Static exists first, objects exist later

Shared by all objects

Save memory space

When a member is statically decorated, it can be called directly by the class name in addition to the object

Class name. Static member

Use attention

Static methods can only access static members (methods and variables)

Non-static methods can access both static and non-static methods

You cannot write the this, super keyword in a static method

Because static takes precedence over object existence, this cannot appear in static methods

The main function is static

publicstaticvoidmain(String[]args){}

When to use static?

You do this in two ways: because static modifiers include member variables and functions.

When to define static variables (class variables)

When Shared data appears in an object, the data is statically decorated. The specific data in the object is defined to exist in heap memory as non-static.

When to define a static function

A function can be defined as static when non-static data (object-specific data) is not accessed internally.

Static pros and cons

Leon:

1. Store the Shared data of the object in a separate space to save space. It is not necessary to store 1 copy per object.

2, can be directly called by the class name

Disadvantages:

1. Too long life cycle

2. Limited access (only static access)

Memory structure

The Java program needs to allocate space in memory while it is running. In order to improve the efficiency of computing, the space is divided into different areas, because each area has a specific way of processing data and memory management.

Stack memory

Used to store local variables. When the data is used up, the space occupied will be released automatically

Heap memory

Arrays and objects (entities), established by new instances are stored in a heap memory (member variables with the establishment of the object, is present in the object's heap memory) every one entity has a memory address value (variable by address references) variables with the entity has the default initialization value entity will no longer be used, will be in the uncertain time reclaimed by the garbage collector (gc)

Method area, local method area, register

validation

加载顺序	父类静态变量=1	父类非静态变量=1	子类静态变量=1	子类非静态变量=1
【父类调用父类静态方法】	Parent.pStaticMethod();
父类静态初始化块1	2
父类静态初始化块2	3
父类静态方法	4
【子类调用子类静态方法】	Child.cStaticMethod();
子类静态初始化块1	5		2
子类静态初始化块2	6		3
子类静态方法	7		4
【子类实例化】	Child c=new Child();
父类非静态初始化块1	8	2
父类非静态初始化块2	9	3
父类构造方法	10	4
子类非静态初始化块1	11	5	5	2
子类非静态初始化块2	12	6	6	3
子类构造方法	13	7	7	4
【父类实例化子类对象】	Parent p=new Child();
父类非静态初始化块1	14	2
父类非静态初始化块2	15	3
父类构造方法	16	4
子类非静态初始化块1	17	5	8	2
子类非静态初始化块2	18	6	9	3
子类构造方法	19	7	10	4

加载顺序	父类静态变量=1	父类非静态变量=1	子类静态变量=1	子类非静态变量=1
【子类实例化】	Child c=new Child();
父类静态初始化块1	2
父类静态初始化块2	3
子类静态初始化块1	4		2
子类静态初始化块2	5		3
父类非静态初始化块1	6	2
父类非静态初始化块2	7	3
父类构造方法	8	4
子类非静态初始化块1	9	5	4	2
子类非静态初始化块2	10	6	5	3
子类构造方法	11	7	6	4
【父类实例化子类对象】	Parent p=new Child();
父类非静态初始化块1	12	2
父类非静态初始化块2	13	3
父类构造方法	14	4
子类非静态初始化块1	15	5	7	2
子类非静态初始化块2	16	6	8	3
子类构造方法	17	7	9	4
【父类调用父类静态方法】	Parent.pStaticMethod();
父类静态方法	18
【子类调用子类静态方法】	Child.cStaticMethod();
子类静态方法	19		10

public class ClassTest {  
  public static void main (String args[]) {
    System.out.println(" [Subclass instantiation] |Child c=new Child();");   
    Child c=new Child();
    System.out.println(" [Parent class Instantiation subclass object] |Parent p=new Child();");    
    Parent p=new Child();
    System.out.println(" [Superclass calls superclass static methods] |Parent.pStaticMethod();");
    Parent.pStaticMethod();
    System.out.println(" [Subclass calls subclass static method] |Child.cStaticMethod();");
    Child.cStaticMethod();
  }
}

public class ClassTest2 {  
  public static void main (String args[]) {
    System.out.println(" [Superclass calls superclass static methods] |Parent.pStaticMethod();");
    Parent.pStaticMethod();
    System.out.println(" [Subclass calls subclass static method] |Child.cStaticMethod();");
    Child.cStaticMethod();
    System.out.println(" [Subclass instantiation] |Child c=new Child();");   
    Child c=new Child();
    System.out.println(" [Parent class Instantiation subclass object] |Parent p=new Child();");    
    Parent p=new Child();
  }
}

public class Parent {
  //  Parent static variables 
  static int m = 1;  
  //  Parent non-static variables 
  int n = 1;
 
  //  Static statement block 1
  static {
    m++;
    // j++;  A parent non-static variable cannot be used in a static statement block 
    System.out.println(" The parent class initializes the block statically 1|" + m);
  }
  //  Static statement block 2
  static {
    m++;
    System.out.println(" The parent class initializes the block statically 2|" + m);
  }
 
  //  The constructor 
  public Parent() {
    m++;
    n++;
    System.out.println(" Superclass constructors |" + m + "|" + n);
  }
 
  //  Non-static statement block 
  {
    m++;
    n++;
    System.out.println(" The parent class non-statically initializes the block 1|" + m + "|" + n);
  }
 
  //  Non-static statement block 
  {
    m++;
    n++;
    System.out.println(" The parent class non-statically initializes the block 2|" + m + "|" + n);
  }
 
  //  Nonstatic method 
  public void pMethod() {
    m++;
    n++;
    System.out.println(" Parent non-static methods |" + m + "|" + n);
    return;
  }
 
  //  A static method 
  public static void pStaticMethod() {
    m++;
//   j++;  Parent class non-static variables cannot be used in static methods 
    System.out.println(" Parent static methods |" + m);
    return;
  }
 
  @Override
  protected void finalize() throws Throwable {
    super.finalize();
    System.out.println(" Destruction of the parent class |");
  }
}

public class Child extends Parent {
  //  A static variable 
  static int i = 1;
  //  Nonstatic variable 
  int j = 1;
 
  //  Static statement block 1
  static {
    m++;
    i++;
    // j++;  Non-static variables cannot be used in static statement blocks 
    System.out.println(" A subclass initializes the block statically 1 " + "|" + m + "||" + i);
  }
  //  Static statement block 2
  static {
    m++;
    i++;
    System.out.println(" A subclass initializes the block statically 2 " + "|" + m + "||" + i);
  }
 
  //  The constructor 
  public Child() {
    m++;
    n++;
    i++;
    j++;
    System.out.println(" Subclass constructor  " + "|" + m + "|" + n + "|" + i + "|" + j);
  }
 
  //  Non-static statement block 
  {
    m++;
    n++;
    i++;
    j++;
    System.out.println(" A subclass non-statically initializes a block 1" + "|" + m + "|" + n + "|" + i + "|" + j);
  }
  //  Non-static statement block 
  {
    m++;
    n++;
    i++;
    j++;
    System.out.println(" A subclass non-statically initializes a block 2" + "|" + m + "|" + n + "|" + i + "|" + j);
  }
 
  //  Nonstatic method 
  public void pMethod() {
    m++;
    n++;
    i++;
    j++;
    System.out.println(" Subclasses inherit non-static methods " + "|" + m + "|" + n + "|" + i + "|" + j);
    return;
  }
 
  //  A static method 
  public static void pStaticMethod() {//  Static methods cannot be inherited 
    m++;
    i++;
    // j++;  Non-static variables cannot be used in static methods 
    return;
  }
 
  //  Nonstatic method 
  public void cMethod() {
    m++;
    n++;
    i++;
    j++;
    System.out.println(" Subclass non-static methods " + "|" + m + "|" + n + "|" + i + "|" + j);
    return;
  }
 
  //  A static method 
  public static void cStaticMethod() {
    m++;
    i++;
    // j++;  Non-static variables cannot be used in static methods 
    System.out.println(" Subclass static method  " + "|" + m + "||" + i);
    return;
  }
 
  @Override
  protected void finalize() throws Throwable {
    super.finalize();
    System.out.println(" Destruction of the subclass |");
  }
}

conclusion

That's the end of this article on the Java classloading process, and I hope you found it helpful. If you have any questions, please feel free to leave a message. This site will reply to you in time. We look forward to your valuable comments.