Java object initialization

Java object initialization
11:02:48 Xiaodong (Zhuhai)
We know that an object can have static variables, variables, static initialization blocks, and initialization blocks. How can we Initialize an object when we create it? In what order is initialization performed?
 
Public class Test {
 

// Static variables
Public static String staticField = "static variable"; // variable
Public String field = "variable ";
// Static initialization Block
Static {
System. out. println (staticField );
System. out. println ("static initialization block ");
}
// Initialize the block
{
System. out. println (field );
System. out. println ("initialization block ");
}
// Constructor
Public Test (){
System. out. println ("constructor ");
}
Public static void main (String [] args ){
Test test = new Test ();
 
}
}
 
Run the code and the output result is:
Static variables
Static initialization Block
Variable
Initialization Block
Constructor
 
 
We can see that when a new object is created, it is not just a constructor method, but an attribute variable first. We change the definition order of the variable and then execute it. We will find that, static is implemented before non-static. What is the sequence between static variables and static initialization blocks, and between variables and initialization blocks? Are static variables always initialized before the static initialization block, and variables always initialized before the initialization block?
Let's first change the code:
 
Public class Test {
 
Public static TestA ta = new TestA ();
// Static variables
Public static String staticField = "static variable"; // variable
Public String field = "variable ";
// Static initialization Block
Static {
System. out. println (staticField );
System. out. println ("static initialization block ");
}
// Initialize the block
{
System. out. println (field );
System. out. println ("initialization block ");
}
// Constructor
Public Test (){
System. out. println ("constructor ");
}
Public static void main (String [] args ){
Test test = new Test ();
 
}
}
 
Class TestA {
Public TestA (){
System. out. println ("Test -- ");
}
}
The output is:
Test --
Static variables
Static initialization Block
Variable
Initialization Block
Constructor
 
 
Static variable: static TestA ta = new TestA () before the static initialization block, the Test --
Change the location and place static TestA ta = new TestA () in the static initialization block. We find that the output is:
Static variables
Static initialization Block
Test --
Variable
Initialization Block
Constructor
 
 
It can be seen that this depends on the order in which they appear in the class. Likewise, this can be achieved between variables and initialization blocks. In summary, the initialization priority is (static variables/static initialization blocks)> (variable/initialization block)> constructor.
 
 
What is the initialization of the inheritance relationship? As follows:
You should know that the parent class will be initialized first when initializing the subclass, and then look at the Code:
 
Public class Test extends Parent {
// Static variables
Public static String staticField = "subclass static variable"; // variable
Public String field = "subclass variable ";
// Static initialization Block
Static {
System. out. println (staticField );
System. out. println ("subclass static initialization block ");
}
// Public static TestA ta = new TestA ();
// Initialize the block
{
System. out. println (field );
System. out. println ("subclass initialization block ");
}
// Constructor
Public Test (){
System. out. println ("subclass constructor ");
}
Public static void main (String [] args ){
Test test = new Test ();
}
}
 
Class Parent {
 
Public String field = "parent variable"; // variable
Public static String staticField = "parent static variable"; // static variable
// Static initialization Block
Static {
System. out. println (staticField );
System. out. println ("parent class static initialization block ");
}
// Initialize the block
{
System. out. println (field );
System. out. println ("parent class initialization block ");
}
// Constructor
Public Parent (){
System. out. println ("parent class constructor ");
}
}
The result is as follows:
Parent static variable
Static initialization block of the parent class
Static subclass Variables
Static initialization block of subclass
Parent variable
Parent class initialization Block
Parent class Constructor
Subclass variable
Subclass initialization Block
Subclass Constructor
 
The result shows that the parent class is not fully initialized before the subclass initialization, the initialization of static variables and static initialization blocks of subclass is completed before the initialization of the parent class variables, initialization blocks, and constructors.
 
Create another object in the main method, Test test2 = new Test ();
What about test2 initialization?
 
To be nice, add multiple lines of code in the subclass constructor: System. out. println ("***********");
Output result:
Parent static variable
Static initialization block of the parent class
Static subclass Variables
Static initialization block of subclass
Parent variable
Parent class initialization Block
Parent class Constructor
Subclass variable
Subclass initialization Block
Subclass Constructor
***********
Parent variable
Parent class initialization Block
Parent class Constructor
Subclass variable
Subclass initialization Block
Subclass Constructor
***********

What have you found?
Static variables and static code blocks are loaded only once.
 
 
Summary:
I. Initialization priority:
1. Static variables/static initialization blocks)> (variables/initialization blocks)> Constructors
2. parent class> subclass

2. Static variables and static code blocks are loaded only once because they are shared globally.