静态代码块&非静态代码块&构造函数

　　　总结：静态代码块总是最先执行。非静态代码块跟非静态方法一样，跟对象有关。只不过非静态代码块在构造函数之前执行。父类非静态代码块、构造函数执行完毕后（相当于父类对象初始化完成）， 才开始执行子类的非静态代码块和构造函数。　

　　相同点：都是在JVM加载类时且在构造方法执行之前执行，在类中都可以定义多个，一般在代码块中对一些static变量进行赋值。

　　不同点：静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。

　　　　静态代码块只在第一次new执行一次，之后不再执行，而非静态代码块在每new一次就执行一次。非静态代码块可在普通方法中定义(不过作用不大)；而静态代码块不行。JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

Example1：

1. public class PuTong {
2. public PuTong(){
3. System.out.print("默认构造方法！-->");
4. }
5. //非静态代码块
6. {
7. System.out.print("非静态代码块！-->");
8. }
9. //静态代码块
10. static{
11. System.out.print("静态代码块！-->");
12. }
13. public static void test(){
14. {
15. System.out.println("普通方法中的代码块！");
16. }
17. }
18. }
19. //测试类
20. public class TestClass {
21. /**
22. * 区别两次new静态与非静态代码块执行情况
23. */
24. public static void main(String[] args) {
25. PuTong c1 = new PuTong();
26. c1.test();
27. PuTong c2 = new PuTong();
28. c2.test();
29. }
30. }
31. /*
32. 运行输出结果是：
33. 静态代码块！-->非静态代码块！-->默认构造方法！-->普通方法中的代码块！
34. 非静态代码块！-->默认构造方法！-->普通方法中的代码块！
35. */

Example2:

1. package tags;
2. public class Child extends Father{
3. static {
4. System.out.println("child-->static");
5. }
6. private int n = 20;
7. {
8. System.out.println("Child Non-Static");
9. n = 30;
10. }
11. public int x = 200;
12. public Child() {
13. this("The other constructor");
14. System.out.println("child constructor body: " + n);
15. }
16. public Child(String s) {
17. System.out.println(s);
18. }
19. public void age() {
20. System.out.println("age=" + n);
21. }
22. public void printX() {
23. System.out.println("x=" + x);
24. }
25. public static void main(String[] args) {
26. new Child().printX();
27. }
28. }
29. class Father {
30. static {
31. //System.out.println("n+"+n);
32. //当n定义在下面时，会提示Cannot reference a field before it is defined，
33. //所以必须把n定义移到上面才可以输出
34. System.out.println("super-->static");
35. }
36. public static int n = 10;
37. public int x = 100;
38. public Father() {
39. System.out.println("super's x=" + x);
40. age();
41. }
42. {
43. System.out.println("Father Non-Static");
44. }
45. public void age(){
46. System.out.println("nothing");
47. }
48. }

结果：

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

　　　　父类静态代码块 -> 子类静态代码块-> 父类非静态代码块 -> 父类构造函数-> 子类非静态代码块 -> 子类构造函数

java中，在使用new操作符创建一个类的实例对象的时候，开始分配空间并将成员变量初始化为默认的数值，注意这里并不是指将变量初始化为在变量定义处的初始值，而是给整形赋值0，给字符串赋值null 这一点于C++不同，（student.name = null , student.age = 0 ）然后在进入类的构造函数。在构造函数里面，首先要检查是否有this或者super调用，this调用是完成本类本身的构造函数之间的调用，super调用是完成对父类的调用。二者只能出现一个，并且只能作为构造函数的第一句出现。在调用this和super的时候实现程序的跳转，转而执行被调用的this构造函数或者super构造函数。在this和super执行完毕，程序转而执行在类定义的时候进行的变量初始化工作。这个执行完毕，才是构造函数中剩下的代码的执行。