Class initialization sequence in Java, Java initialization sequence
I. initialization sequence of a class (without inheritance)
Rules:
1. Static variables> common variables> Constructor
2. The order in which variables are defined determines the initialization order.
3. Static variables are the same as static blocks. Common variables are the same as non-static blocks. You can regard static blocks as static variables and non-static blocks as common variables.
Public class Test1 {public static void main (String [] args) {new D () ;}} class C {public C (String s) {System. out. println (s) ;}} class D {/* D constructor */public D () {System. out. println ("D constructor");}/* D non-static variable */private C c1 = new C ("variable 1 "); private C c2 = new C ("variable 2");/* D static variable */private static C c3 = new C ("static variable 1 "); private static C c4 = new C ("static variable 2");/* D static initialization block */static {System. out. println ("D Static initialization block .. ");}/* D instance initialization block */{System. out. println (" D instance initialization block .. ");}}
Execution result:
Static variable 1
Static variable 2
D ..
Variable 1
Variable 2
D ..
D Constructor
Ii. initialization sequence of a class (with inheritance)
Rules:
1. parent class initialization> subclass Initialization
2. Static variables> common variables> Constructor
3. The order in which variables are defined determines the initialization order.
4. Static variables are the same as static blocks. Common variables are the same as non-static blocks. You can regard static blocks as static variables and non-static blocks as normal variables.
Public class Test2 {public static void main (String [] args) {new B () ;}} class Feild {public Feild (String s) {System. out. println (s) ;}} class A {/* A constructor */public A () {System. out. println ("parent class constructor");}/* A non-static variable */private Feild f1 = new Feild ("parent class variable 1 "); private Feild f2 = new Feild ("parent variable 2");/* static variable */private static Feild f3 = new Feild ("parent static variable 1 "); private static Feild f4 = new Feild ("parent static variable 2");/* static initialization block of A */s Tatic {System. out. println ("static initialization block of the parent class .. ");}/* A instance initialization block */{System. out. println (" parent class instance initialization block .. ") ;}} Class B extends A {/* B constructor */public B () {System. out. println ("subclass constructor");}/* B's non-static variable */private Feild f5 = new Feild ("subclass variable 1 "); private Feild f6 = new Feild ("subclass variable 2");/* static variable of B */private static Feild f7 = new Feild ("subclass static variable 1 "); private static Feild f8 = new Feild ("subclass static variable 2");/* static initialization block of B */static {System. out. the static initialization block of the println ("subclass .. ");}/* B instance initialization block */{System. out. println (" subclass instance initialization block .. ");}}
Execution result:
Parent static variable 1
Parent static variable 2
Static initialization block of the parent class ..
Subclass static variable 1
Subclass static variable 2
Static initialization block of the subclass ..
Parent variable 1
Parent variable 2
The initialization block of the parent class ..
Parent class Constructor
Subclass variable 1
Subclass variable 2
The initialization block of the subclass instance ..
Subclass Construction Method