Static code blocks & non-static code blocks & constructors

Summary: static code blocks are always executed first. A non-static block of code, like a non-static method, is related to an object. Only non-static blocks of code are executed before the constructor. A non-static block of code and a constructor for a subclass are only started when the parent class is non-static and the constructor finishes executing (equivalent to the initialization of the parent class object).　

The same point: when the JVM loads the class and executes before the construction method executes, you can define more than one in the class, typically assigning some static variables to the code block.

Different points: Static code blocks are executed before non-static blocks of code (static code blocks, non-static code blocks, and construction methods).

A static code block executes only once for the first time, and then no longer executes, rather than a static block of code that executes once per new. A non-static block of code can be defined in a common method (though not very useful), while a static block of code does not. The JVM executes these static blocks of code when the class is loaded, and if there are multiple static blocks of code, the JVM executes them sequentially in the order in which they appear in the class, and each block is executed only once.

Example1:

2. Public class Putong {
4. Public Putong () {
6. System.out.print ("default constructor Method!  --");
8. }
12. //non-static code block
14. {
16. System.out.print ("Non-static code block!  --");
18. }
22. //Static code block
24. static{
26. System.out.print ("Static code block!  --");
28. }
32. public static void Test () {
34. {
36. System.out.println ("code blocks in the normal Method!")  ");
38. }
40. }
42. }
46. Test class
48. Public class TestClass {
52. /** 
54. * Distinguish between two times new static and non-static blocks of code execution
56. */
58. public static void Main (string[] args) {
60. Putong C1 = new Putong ();
62. C1.test ();
66. Putong C2 = new Putong ();
68. C2.test ();
70. }
72. }
76. /*
78. The results of the run output are:
80. Static code block! --Non-static code block! --default constructor Method! --code blocks in the normal method!
82. Non-static code block! --default constructor Method! --code blocks in the normal method!
84. */ 
    

Example2:

2. Package tags;
6. Public class child extends father{
10. Static {
12. System.out.println ("child-->static");
14. }
18. private int n = 20;
22. {
24. System.out.println ("Child non-static");
26. n = 30;
28. }
32. public int x = 200;
36. Public child () {
38. This ("The other constructor");
40. System.out.println ("Child constructor Body:" + N);
42. }
46. Public child (String s) {
48. System.out.println (s);
50. }
54. public void Age () {
56. System.out.println ("age=" + N);
58. }
62. public void Printx () {
64. System.out.println ("x=" + x);
66. }
70. public static void Main (string[] args) {
72. new Child (). Printx ();
74. }
76. }
80. Class Father {
84. Static {
86. //system.out.println ("n+" +n);
88. //When n is defined below, you will be prompted cannot reference a field before it is defined,
90. //So the n definition must be moved above to output
92. System.out.println ("super-->static");
94. }
98. public static int n = 10;
100. public int x = 100;
104. Public Father () {
106. System.out.println ("Super ' s x=" + x);
108. Age ();
110. }
114. {
116. System.out.println ("Father non-static");
118. }
122. public void Age () {
124. System.out.println ("nothing");
126. }
128. }

Results:

Super-->static

Child-->static

Father non-static

Super ' s x=100

Age=0

Child non-static

The other constructor

Child constructor Body:30

x=200

Parent class static code block, subclass static code block, parent class non-static code block-parent class constructor-subclass non-static code block-subclass constructor

In Java, when you create an instance object of a class using the new operator, you begin to allocate space and initialize the member variable to the default value, note that this does not mean that the variable is initialized to the initial values at the variable definition, but instead assigns a value of 0 to the shape and assigns null to the string, which is different from C + +. (Student.name = null, Student.age = 0) and then enters the constructor of the class. Inside the constructor, the first thing to check for this or super call is to complete the call between the constructors of the class itself, and the super call is to complete the call to the parent class. The two can only appear in one, and can only appear as the first sentence of the constructor. Implement the program's jump when calling this and super, instead of executing the called this constructor or super constructor. At the end of this and super, the program performs the initialization of the variables at the time of the class definition. This completes the execution of the remaining code in the constructor.

Static code blocks & non-static code blocks & constructors