顺便在说明一下，三者在内存之间的执行先后顺序

1. 1 普通代码块
   
2. 
   
3. 
   
4. 
   
5. //普通代码块：在方法或语句中出现的{}就称为普通代码块。普通代码块和一般的语句执行顺序由他们在代码中出现的次序决定--“先出现先执行”
   
6.   public class CodeBlock01{
   
7.         public static void main(String[] args){
   
8.             
   
9.               {
   
10.                 int x=3;
    
11.                System.out.println("1,普通代码块内的变量x="+x);   
    
12.              }
    
13.             
    
14.              int x=1;
    
15.              System.out.println("主方法内的变量x="+x);
    
16.             
    
17.              {
    
18.                 int y=7;
    
19.                 System.out.println("2,普通代码块内的变量y="+y);   
    
20.              }
    
21.            }
    
22.      }
    
23.      
    
24.     /*
    
25.     运行结果：
    
26.    1,普通代码块内的变量x=3
    
27.          主方法内的变量x=1
    
28.           2,普通代码块内的变量y=7
    
29.     */
    
30.    
    
31. 
    
32. 
    
33. 
    
34. 
    
35. 2 构造代码块
    
36. 
    
37. 
    
38. 
    
39. //构造块：直接在类中定义且没有加static关键字的代码块称为{}构造代码块。构造代码块在创建对象时被调用，每次创建对象都会被调用，并且构造代码块的执行次序优先于类构造函数。
    
40. 
    
41. public class CodeBlock02{
    
42.     {
    
43.       System.out.println("第一代码块");   
    
44.     }
    
45.    
    
46.     public CodeBlock02(){
    
47.         System.out.println("构造方法");
    
48.         }
    
49.         
    
50.         {
    
51.           System.out.println("第二构造块");
    
52.         }
    
53.       public static void main(String[] args){
    
54.           new CodeBlock02();
    
55.           new CodeBlock02();
    
56.           new CodeBlock02();
    
57.            
    
58.     }
    
59. }   
    
60. 
    
61. /*
    
62. *
    
63. 执行结果：
    
64. 第一代码块
    
65. 第二构造块
    
66. 构造方法
    
67. 第一代码块
    
68. 第二构造块
    
69. 构造方法
    
70. 第一代码块
    
71. 第二构造块
    
72. 构造方法
    
73. */
    
74. 
    
75. 
    
76. 
    
77. 
    
78. 3 静态代码块
    
79. 
    
80. 
    
81. 
    
82. //静态代码块:在java中使用static关键字声明的代码块。静态块用于初始化类，为类的属性初始化。每个静态代码块只会执行一次。由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行。
    
83. //如果类中包含多个静态代码块，那么将按照"先定义的代码先执行，后定义的代码后执行"。
    
84. //注意：1 静态代码块不能存在于任何方法体内。2 静态代码块不能直接访问静态实例变量和实例方法，需要通过类的实例对象来访问。
    
85. 
    
86. 
    
87. class Code{
    
88.     {
    
89.       System.out.println("Code的构造块");
    
90.     }
    
91.    
    
92.     static{
    
93.         System.out.println("Code的静态代码块");
    
94.         }
    
95.         
    
96.     public Code(){
    
97.         System.out.println("Code的构造方法");
    
98.         }
    
99.     }
    
100.    
     
101.    
     
102. public class CodeBlock03{
     
103.      {
     
104.       System.out.println("CodeBlock03的构造块");   
     
105.      }
     
106.      
     
107.      static{
     
108.         System.out.println("CodeBlock03的静态代码块");
     
109.         }
     
110.         
     
111.         public CodeBlock03(){
     
112.              System.out.println("CodeBlock03的构造方法");
     
113.             }
     
114.         
     
115.       public static void main(String[] args){
     
116.             System.out.println("CodeBlock03的主方法");
     
117.             new Code();
     
118.             new Code();
     
119.             new CodeBlock03();
     
120.             new CodeBlock03();
     
121.           }
     
122.     }
     
123. /*
     
124. CodeBlock03的静态代码块
     
125. CodeBlock03的主方法
     
126. Code的静态代码块
     
127. Code的构造块
     
128. Code的构造方法
     
129. Code的构造块
     
130. Code的构造方法
     
131. CodeBlock03的构造块
     
132. CodeBlock03的构造方法
     
133. CodeBlock03的构造块
     
134. CodeBlock03的构造方法
     
135. */
     
136. 
     
137. 
     
138. 
     

复制代码

我是来向楼上学习的

楼主总结的太好了，膜拜

过来学习 ，下

构造代码块和构造方法都是给类进行初始化的，如果有多个代码块就按代码块的出现的先后顺序执行，让你后在执行构造方法

静水流华 发表于 2014-9-11 16:02
构造代码块和构造方法都是给类进行初始化的，如果有多个代码块就按代码块的出现的先后顺序执行，让你后在执 ...

没创建一个对象就会执行一遍

↘ふ紫铯幽夢 发表于 2014-5-31 10:51

感谢分享

总结：
1、构造代码块用于类的初始化操作，静态构造代码块只执行一次，而构造代码块在每次创建对象时都执行；
2、构造方法用于对象的初始化操作，即创建对象是通过调用相应的构造方法来实现的；
3、 普通代码块的使用，一般来说是没有意义的，唯一的用途可能是用来限定变量的作用域/生命周期了吧
  对吧？！:lol

静态代码块是内存在加载时执行的

↘ふ紫铯幽夢 发表于 2014-5-31 10:51

总结的很好，案例很有代表性。不过如果在有继承的类中子父类都有静态代码块，构造代码块等，子类的静态代码块的执行次序看起来就不那么直观了

这个我很容易混淆，谢谢你的整理！！！