静态代码块、构造代码块都进行哪些初始化操作？在设计中常用吗？

请问这个的结果是什么：
public class StaticCode {
        public static void main(String[] args) {
                Code code1 = new Code();
               
                Code code2 = new Code();
        }

}
class Code{
        {
                System.out.println("普通的代码块...");
        }
       
        static{
                System.out.println("静态代码块...");
        }
       
        public Code(){
                System.out.println("构造方法...");
        }
}

王钊 发表于 2013-2-20 10:34
给你举个静态代码块和构造代码块的例子：首先，初始化块总是在构造函数之前执行，在新建子类对象时，先执行 ...

谢了，又补充了父类与子类关于初始化块的知识了！

静态代码块，主要是对类变量进行初始化操作，类变量属于java类本身，只有当程序初始化该java类时才会为该类的类变量分配内存空间，并执行初始化。java虚拟机对一个java类只初始化一次，因此java程序每运行一次，系统只为类变量分配一次内存空间，执行一次初始化。
构造代码块，主要是对实例变量进行初始化。实例变量可以在三个地方进行初始化，第一，定义实例变量时指定初始化值。第二，非静态初始化块中对实例变量指定初始值。第三，构造方法中初始化实例变量。第一种或第二种最先获得执行。   但是当你使用javap -c 类名。分析代码，就会发现，三种初始化作用都一样。经编译器处理后，第一种和第二中的赋值语句都将合并到构造方法中（第一种和第二种的赋值语句位于构造方法自身代码的前面）。

王钊 发表于 2013-2-20 10:34
给你举个静态代码块和构造代码块的例子：首先，初始化块总是在构造函数之前执行，在新建子类对象时，先执行 ...

学习了。。。

给你举个静态代码块和构造代码块的例子：

1. public class Test
   
2. {
   
3.     public static void main(String[] args)  
   
4.     {
   
5.                  new Student();
   
6.         }
   
7. 
   
8. }
   
9. 
   
10. class Person
    
11. {
    
12. 
    
13.         static
    
14.         {
    
15.                 System.out.println("Person static block!");
    
16.         }
    
17. 
    
18.         {
    
19.                 System.out.println("Person 构造代码块执行！");
    
20.         }
    
21. 
    
22.         public Person()
    
23.         {
    
24.                 System.out.println("Person 构造函数执行！");
    
25.         }
    
26. }
    
27. 
    
28. class Student extends Person
    
29. {
    
30.         static
    
31.         {
    
32.                 System.out.println("Student static block!");
    
33.         }
    
34. 
    
35.         {
    
36.                 System.out.println("Student 构造代码块执行！");
    
37.         }
    
38. 
    
39.         public Student()
    
40.         {
    
41.                 //super()默认调用父类不带参数的构造函数
    
42.                 System.out.println("Student 构造函数执行！");
    
43.         }
    
44. 
    
45. 
    
46. }
    
47. 
    
48. //---------- 运行Java程序 ----------
    
49. //Person static block!
    
50. //Student static block!
    
51. //Person 构造代码块执行！
    
52. //Person 构造函数执行！
    
53. //Student 构造代码块执行！
    
54. //Student 构造函数执行！

复制代码

首先，初始化块总是在构造函数之前执行，在新建子类对象时，先执行最顶层父类的初始化块，依次向下执行其父类的初始化块，开始执行其父类的构造器……最后才执行该类的初始化块和构造器，返回该类的对象。
其次，静态初始化块是类相关的，系统在类初始化阶段执行静态初始化块，而不是在创建对象时才执行。因此静态代码块总是比普通初始化块先执行。
所以上个例子，new出来一个子类的对象，首先加载父类和子类，固Person和Stsudent的静态代码块依次先执行，类加载后，调用Student()构造器，默认调用super()，而普通构造代码块先于构造器执行，所以先调用Person的构造代码块，再调用Person构造器，之后就是Student的构造代码块和Student构造器。。

下面的代码能直观的显示出静态代码块、构造代码块、构造函数的执行顺序。作用楼上的已经说了

1. 
   
2. class person
   
3. {
   
4.         //静态代码块先执行，构造代码块执行，构造函数执行
   
5.         person()
   
6.         {
   
7.                 System.out.println("构造函数 3!");
   
8.         }
   
9.         static
   
10.         {
    
11.                 System.out.println("静态代码块 1");
    
12.         }
    
13.        
    
14.         {
    
15.                 System.out.println("构造代码块 2");
    
16.         }
    
17.        
    
18.        
    
19. }
    
20. class personDemo2
    
21. {
    
22.         public static void main(String[] args)
    
23.         {
    
24.                 person p =new person();
    
25.         }
    
26. }
    

复制代码

静态代码块是随着类的加载而执行的，只执行一次。是给类进行初始化的。而构造代码块是给对象进行统一初始化的，主要是给不同对象的共性进行初始化。在对象的初始化过程中，当类文件加载后就会执行静态代码块给类初始化，而构造代码块是要等对象建立后给对象进行初始化的。

静态代码块是给类进行初始化的，构造代码块是给对象进行初始化的，后面的问题我也太清楚，对不住呀，我只知道这些。见谅。