Main contents:

1 Initialization order of JAVA without inheritance

Initialization order in case of 2 JAVA inheritance

JAVA initialization sequence without inheritance

 1 class Sample
 2 {
 3       Sample(String s)
 4       {
 5             System.out.println(s);
 6       }
 7       Sample()
 8       {
 9             System.out.println("Sample The default constructor is called");
10       }
11 }
12 class Test{
13       static Sample sam=new Sample("Static member sam Initialization");
14       Sample sam1=new Sample("sam1 Membership initialization");
15       static{
16             System.out.println("static Block execution");
17             if(sam==null)System.out.println("sam is null");
18             sam=new Sample("Initialization in static block sam Member variables");
19             }
20       Test()
21       {
22             System.out.println("Test The default constructor is called");
23       }
24 }
25 //Main function
26  public static void  main(String  str[])
27 {
28      Test a=new Test();
29  }

The output results are as follows:

Static member sam initialization - - - static member initialization

static Block Execution -- static Block Executed

Initialization of sam member variables within static blocks -- static block execution

Sa1 member initialization - - - ordinary member initialization

Test default constructor called - - - constructor execution

It can be concluded that:

A. Static member variables are initialized first (note that Static can be seen as a static member whose execution order depends on the order it declares in the class)

b Ordinary member initialization

c executes the constructor.

 

For static members (static blocks can be regarded as ordinary static members, which are not necessarily executed first in class initialization) and ordinary members, their initialization order is only related to their order in class definition, and has nothing to do with other factors.

For example, the following example:

 1 class Test{
 2       static{
 3             System.out.println("static Block 1  implement");
 4             }
 5       static Sample staticSam1=new Sample("Static member staticSam1 Initialization");
 6       Sample sam1=new Sample("sam1 Membership initialization");
 7       static Sample staticSam2=new Sample("Static member staticSam2 Initialization");
 8       static{
 9             System.out.println("static Block 2  implement");
10             }
11       Test()
12       {
13             System.out.println("Test The default constructor is called");
14       }
15       Sample sam2=new Sample("sam2 Membership initialization");
16 }

The results are as follows:

static Block 1 Execution

Initialization of static member staticSam1

Static member staticSam2 initialization

static block 2 executes

Static Members

sam1 member initialization

sam2 member initialization

Ordinary Members

Test default constructor called

Constructor

Initialization order in case of JAVA inheritance

 1 class Sample {
 2     Sample(String s) {
 3         System.out.println(s);
 4     }
 5 
 6     Sample() {
 7         System.out.println("Sample The default constructor is called");
 8     }
 9 }
10 
11 class Test {
12     static {
13         System.out.println("Parent class static Block 1 execution");
14     }
15 
16     static Sample staticSam1 = new Sample("Static member of parent class staticSam1 Initialization");
17     Sample sam1 = new Sample("Parent class sam1 Membership initialization");
18     static Sample staticSam2 = new Sample("Static member of parent class staticSam2 Initialization");
19 
20     static {
21         System.out.println("Parent class static Block 2 execution");
22     }
23 
24     Test() {
25         System.out.println("Parent class Test The default constructor is called");
26     }
27 
28     Sample sam2 = new Sample("Parent class sam2 Membership initialization");
29 }
30 
31 class TestSub extends Test {
32     static Sample staticSamSub = new Sample("Subclass static members staticSamSub Initialization");
33 
34     TestSub() {
35         System.out.println("Subclass TestSub The default constructor is called");
36     }
37 
38     Sample sam1 = new Sample("Subclass sam1 Membership initialization");
39     static Sample staticSamSub1 = new Sample("Subclass static members staticSamSub1 Initialization");
40 
41     static {
42         System.out.println("Subclass static Block execution");
43     }
44 
45     Sample sam2 = new Sample("Subclass sam2 Membership initialization");
46 }

Implementation results:

The parent static block 1 executes

staticSam1 initialization of static member of parent class

staticSam2 initialization of static member of parent class

The parent static block 2 executes

Initialization of static members of the parent class

staticSamSub initialization of static member of subclass

Initialization of static member staticSamSub1 of subclass

Subclass static block execution

Subclass static member initialization

Initialization of the parent sam1 member

Initialization of parent sam2 members

The default constructor of parent Test is called.

Initialization of normal members of the parent class and execution of constructors

Subclass sam1 member initialization

Subclass sam2 member initialization

The default constructor of the subclass TestSub is called

Initialization of normal members of the parent class and execution of constructors

The conclusion of JAVA initialization sequence is drawn as follows:

1 Initialization of all static members of the inheritance system (first parent class, then subclass)

2 Parent Class Initialization Completed (Initialization of Common Members - > Call of Constructor)

3 subclass initialization (common member - > constructor)

The order of JAVA initialization is as follows: