Java object and Memory Management

1. Memory Allocation for instance variables and class variables

Class variables: The member variables modified using static are class variables and belong to the class itself.

Instance variable: A member variable that does not use static modification is an instance variable and belongs to this class.

Since each fatigue in the same JVM only corresponds to one Class object, the Class variables of one Class in the same JVM only need one memory space.

For instance variables, if this class does not create an instance once, you need to allocate a memory space for the instance variables. Therefore, there are several instances in the program, and the instance variables need several pieces of memory space.

2. the initialization time of class variables is always before the initialization of instance variables.

Let's take a look at the following three pieces of code:

1) because both instance variables are allocated space only when the variable is created, num2 is not allocated yet, so a compilation error occurs in the forward reference.

 
 

  
  
Int num = num2 + 3; // an error is returned if the forward reference is invalid.
  
  
Int num2 = 2
 
 

2) because the two class variables are allocated space when the JVM loads the class, num2 is not yet allocated, so the forward reference will encounter a mutation error.

 
 

  
  
Static int num = num2 + 3; // an error is returned if the forward reference is invalid.
  
  
Tatic int num2 = 2
 
 

3) because the class variable num2 has allocated space when the JVM loads the class, and num has allocated space when creating the instance, num2 has been allocated successfully, therefore, the num forward reference is successful.

 
 

  
  
Int num = num2 + 3; // use it correctly
  
  
Static int num2 = 2;
 
 

The above three code blocks can be used to verify that the initialization time of class variables is always before the initialization of instance variables.

3. Java object initialization method and execution sequence

Java objects can be initialized in three ways: 1) constructor 2) initialization block 3) Specify the initialization value when defining variables

If these three initialization methods appear at the same time, you should note that they also have a rule on the execution sequence:

1) The static initialization block runs only once when the class creates an object for the first time, and will not run later. The non-static initialization block always runs once every time the class creates an object.

 
 

  
  
Public class Test {
  
  
Static {
  
  
System. out. println ("execution --- static initialization code block .");
  
  
}
  
  

  
  
{
  
  
System. out. println ("execution --- non-static initialization code block .");
  
  
}
  
  

  
  
Public static void main (String [] args ){
  
  
For (int I = 1; I <= 2; I ++ ){
  
  
System. out. println ("create the" + I + "object ");
  
  
New Test ();
  
  
System. out. println ();
  
  
}
  
  
}
  
  
}
 
 

 

Running result:

2) each time the constructor creates an object, the constructor must have a chance to execute the object. At this time, the non-static initialization block will also get the opportunity and run before the constructor.

 
 

  
  
Public class Test {
  
  

  
  
{
  
  
System. out. println ("execution --- non-static initialization code block .");
  
  
}
  
  

  
  
Public Test (){
  
  
System. out. println ("execution --- constructor .");
  
  
}
  
  

  
  
Public static void main (String [] args ){
  
  
For (int I = 1; I <= 2; I ++ ){
  
  
System. out. println ("create the" + I + "object ");
  
  
New Test ();
  
  
System. out. println ();
  
  
}
  
  
}
  
  
}
 
 

 

Running result:

3) when defining variables, the execution sequence of the specified initialization values and the initial values in the initialization block is the same as that in the source program.

Verification Code 1:

 
 

  
  
Public class Test {
  
  

  
  
String I = "specifies the initialization value when defining a variable ";
  
  

  
  
{
  
  
I = "initial value specified in the initialization block ";
  
  
}
  
  

  
  
Public static void main (String [] args ){
  
  
For (int I = 1; I <= 2; I ++ ){
  
  
System. out. println ("create the" + I + "object ");
  
  
System. out. println (new Test (). I );
  
  
System. out. println ();
  
  
}
  
  
}
  
  
}
 
 

Running result

Verification Code 2:

 
 

  
  
Public class Test {
  
  

  
  
{
  
  
I = "initial value specified in the initialization block ";
  
  
}
  
  

  
  
String I = "specifies the initialization value when defining a variable ";
  
  

  
  
Public static void main (String [] args ){
  
  
For (int I = 1; I <= 2; I ++ ){
  
  
System. out. println ("create the" + I + "object ");
  
  
System. out. println (new Test (). I );
  
  
System. out. println ();
  
  
}
  
  
}
  
  
}
 
 

Running result:

4. Memory Control for parent and child instances

In general, internal classes are not used for verification, but they are all the same. I am lazy, so I used internal classes. Thank you)

1) when the subclass overrides the parent class method, the parent class only calls its own method for overwriting the quilt class.

 

 
 

  
  
public class Test{ 
  
  
     class Base { 
  
  
         Base() { 
  
  
             this.info(); 
  
  
         } 
  
  
         public void info() { 
  
  
             System.out.println("Base"); 
  
  
         } 
  
  
         public void getInfo() { 
  
  
             info(); 
  
  
         } 
  
  
     } 
  
  
      
  
  
     public class Child extends Base{ 
  
  
         @Override 
  
  
         public void info() { 
  
  
             System.out.println("Child"); 
  
  
         } 
  
  
     } 
  
  
      
  
  
     public static void main(String[] args) { 
  
  
         Test test = new Test(); 
  
  
         Base base = test.new Child(); 
  
  
         base.info(); 
  
  
         base.getInfo(); 
  
  
     } 
  
  
 } 
 
 

Running result:

2) The above is a manifestation of the method in polymorphism, but the method has polymorphism and the instance variable has no polymorphism.

To explain the following sentence: "methods are polymorphism and variables are not polymorphism" means that, in any case, the parent class only calls its own method for overwriting the quilt class. The variables are different. Assume that both the parent class and the subclass have instance variables with the same variable name, the value obtained from the instance variables accessed by the parent class is its own, not its subclass. After the downward transformation, the instance variables accessed through the subclass obtain their own values rather than the parent class.

In many books or instructional videos, when creating a subclass Object, Java will continue to find the Object along the inheritance structure, and then execute the constructor from the Object. Execute the constructor of the parent class first, and then create a member variable pointing to its parent class in its subclass. In fact, this statement is wrong. The system does not really create a parent class object, but not only saves its own instance variables, but also all instance variables of its parent class.

 
 

  
  
Public class Test {
  
  
Class Base {// parent class
  
  
Int I = 2;
  
  
}
  
  

  
  
Public class Child extends Base {// subclass
  
  
Int I = 20;
  
  
}
  
  

  
  
Public static void main (String [] args ){
  
  
Test test = new Test ();
  
  
Child child = test. new Child ();
  
  
Base base = child;
  
  
System. out. println ("Base. I:" + base. I );
  
  
System. out. println ("Child. I:" + child. I );
  
  
}
  
  
}
 
 

Running result:

5. final Modifier

Final is determined at compilation, which is equivalent to a direct volume.

1) final modified instance variable Assignment time:

Specify the initial value when defining final instance variables

The initial value specified for the final instance variable in the non-static initialization module

Specify the initial value for the final instance variable in the constructor.

2) final variable Assignment time:

Specify the initial value when defining final Variables

The initial value specified for the final instance variable in the static initialization module.

Edit recommendations]

1. Java Exception Handling
2. Java security model Introduction
3. Explore the Java language and Lambda expressions in JVM
4. Java online tutorial-Interface
5. Java serialization and JSON serialization Competition