到目前，学到了构造代码块～静态代码块，局部代码块～不知道还有没有别的～～～知道了格式，却不知道具体什么场合适合用代码块～～～学以致用嘛，请大牛举例分析下…

1. 局部代码块：
   
2. 作用：控制变量的生命周期；
   
3. 在程序中，当我们已经使用完 x 后，并且在接下来的代码中，不会再用到x,那么就没必要让x 在内存中占用空间了，这用情况下，可以使用 局部代码块，将x及其所设计到的区域封装为局部代码块，他们在程序执行中顺序不变，只是在执行完成后消失。
   
4. 表现形式，以代码体现如下：
   
5. [java] view plaincopyprint?
   
6. class TestDemo  
   
7. {  
   
8.     public static void main(String[] args)  
   
9.     {  
   
10.         {  
    
11.             int x = 9;  
    
12.             System.out.println(x);  
    
13.         }  
    
14.   
    
15.         System.out.println("Hello World !");  
    
16.     }  
    
17. }  
    
18. 构造代码块：
    
19. 作用：它可以给所有对象进行初始化
    
20. 存在于：类中。
    
21. 当类中的构造方法以重载的形式存在时，并且有共同成员变量或共同的方法时，可以通过构造代码块对其进行初始化；这样可以减少代码的重复！
    
22. [java] view plaincopyprint?
    
23. class Person  
    
24. {  
    
25.     private String name;  
    
26.     private int age;  
    
27.   
    
28.     {  
    
29.         System.out.println("cons code run !");  
    
30.          
    
31.     }   
    
32.   
    
33.     Person() // 给对应的对象进行初始化  
    
34.     {  
    
35.         System.out.println("Person Now：RUN ！");  
    
36.         System.out.println("eat————");  
    
37.     }  
    
38.   
    
39.     Person (String name , int age)  
    
40.     {  
    
41.         this.name = name ;  
    
42.         this.age= age;  
    
43.         System.out.println(this.name + "————" + this.age);  
    
44.         System.out.println("eat————");  
    
45.     }  
    
46.       
    
47. }  
    
48. class ConsCodeDemo  
    
49. {  
    
50.     public static void main(String[] args)  
    
51.     {  
    
52.         Person p = new Person();  
    
53.         Person p1 = new Person("LiSi" , 23);  
    
54.     }  
    
55. }  
    
56. 我们可以看到类Person中 重载的构造方法中有共同的代码System.out.println("eat————");我们可以将他封装进构造代码块，用来给各种进行初始化。
    
57. 优化后，代码体现为：
    
58. [java] view plaincopyprint?
    
59. class Person  
    
60. {  
    
61.     private String name;  
    
62.     private int age;  
    
63.   
    
64.     {  
    
65.         System.out.println("cons code run !");  
    
66.         eat();  
    
67.          
    
68.     }   
    
69.   
    
70.     Person() // 给对应的对象进行初始化  
    
71.     {  
    
72.         System.out.println("Person Now：RUN ！");  
    
73.     }  
    
74.   
    
75.     Person (String name , int age)  
    
76.     {  
    
77.         this.name = name ;  
    
78.         this.age= age;  
    
79.         System.out.println(this.name + "————" + this.age);  
    
80.     }  
    
81.     public void eat()  
    
82.     {  
    
83.         System.out.println("eat————");  
    
84.     }  
    
85.       
    
86. }  
    
87. class ConsCodeDemo  
    
88. {  
    
89.     public static void main(String[] args)  
    
90.     {  
    
91.         Person p = new Person();  
    
92.         Person p1 = new Person("LiSi" , 23);  
    
93.     }  
    
94. }  
    
95. 
    
96. 静态代码块：
    
97. 特点：
    
98. 1. 随着类的加载而执行，而且只一次。
    
99. 2. 优先于主函数执行。
    
100. 
     
101. 作用：给类进行初始化。
     
102. 当类中的方法都被静态了化，并且构造方法被private了，这是我们不能，在将这个类实例化，然而又想让类增加一些属性，就可以使用静态代码块：
     
103. 表现形式，以代码体现如下：
     
104. [java] view plaincopyprint?
     
105. class StaticCode  
     
106. {  
     
107.     static   
     
108.     {  
     
109.         System.out.println("A");  
     
110.     }  
     
111.     public void show()  
     
112.     {  
     
113.         System.out.println("Hello World !");  
     
114.     }  
     
115. }  
     
116. class StaticCodeDemo  
     
117. {  
     
118.     static   
     
119.     {  
     
120.         System.out.println("B");  
     
121.     }  
     
122.     public static void main(String[] args)  
     
123.     {  
     
124.         new StaticCode().show();  
     
125.     }  
     
126.     static  
     
127.     {  
     
128.         System.out.println("C");  
     
129.     }  
     
130. }  
     

复制代码

一个对象在创建的时候要经过如下操作
      父类静态代码块->子类静态代码块->父类非静态代码块->子类非静态代码块->父类构造方法->子类构造方法

    对象的初始化顺序:
首先执行父类静态的内容，父类静态的内容执行完毕后，接着去执行子类的静态的内容，当子类的静态内容执行完毕之后，再去看父类有没有非静态代码块，如果有就执行父类的非静态代码块，父类的非静态代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有非静态代码块，如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法。总之一句话，静态代码块内容先执行，接着执行父类非静态代码块和构造方法，然后执行子类非静态代码块和构造方法。

    注意:子类的构造方法，不管这个构造方法带不带参数，默认的它都会先去寻找父类的不带参数的构造方法。如果父类没有不带参数的构造方法，那么子类必须用supper关键子来调用父类带参数的构造方法，否则编译不能通过。

郭孟涛 发表于 2013-1-28 10:57

终于把这东西搞清楚了，谢谢！！！