public class ExA {  
    private static ExA a = new ExA();  
    static {  
        System.out.println("父类--静态代码块");  
    }  
  
    public ExA() {  
        System.out.println("父类--构造函数");  
    }  
  
    {  
        System.out.println("父类--非静态代码块");  
    }  
  
    public static void main(String[] args) {  
        new ExB();  
    }  
}  
  
class ExB extends ExA {  
    private static ExB b = new ExB();  
    static {  
        System.out.println("子类--静态代码块");  
    }  
    {  
        System.out.println("子类--非静态代码块");  
    }  
  
    public ExB() {  
        System.out.println("子类--构造函数");  
    }  
}  

-------------------------------
执行结果是
父类--非静态代码块
父类--构造函数
父类--静态代码块
父类--非静态代码块
父类--构造函数
子类--非静态代码块
子类--构造函数
子类--静态代码块
父类--非静态代码块
父类--构造函数
子类--非静态代码块
子类--构造函数 -----------------------------------为什么非静态在静态前面执行了呢,求执行流程

1. public class ExA {
   
2. //第一步：在类加载时执行static类型，当new ExA();时先执行代码块，后执行构造方法。
   
3. //第一步输出如下结果：
   
4. /*
   
5. * 父类--非静态代码块
   
6. * 父类--构造函数
   
7. */
   
8. private static ExA a = new ExA();
   
9. //第二步：执行下一条static类型代码输出：
   
10. /*
    
11. * 父类--静态代码块
    
12. */
    
13. static {
    
14. System.out.println("父类--静态代码块");
    
15. }
    
16. 
    
17. public ExA() {
    
18. System.out.println("父类--构造函数");
    
19. }
    
20. 
    
21. {
    
22. System.out.println("父类--非静态代码块");
    
23. }
    
24. //第三步：执行main()方法
    
25. public static void main(String[] args) {
    
26. //然后new ExB()，这时需先加载类ExB的内容，所以执行类加载，
    
27. //类加载时执行private static ExB b = new ExB();new ExB()时因为ExB继承自ExA，所以先new ExA()输出：
    
28. /*
    
29. * 父类--非静态代码块
    
30. * 父类--构造函数
    
31. */
    
32. //然后new ExB()，输出
    
33. /*
    
34. * 子类--非静态代码块
    
35. * 子类--构造函数
    
36. */
    
37. //然后执行static代码块，输出：
    
38. /*
    
39. * 子类--静态代码块
    
40. */
    
41. //类加载完成后才是真正的new ExB()，先new ExA(),输出：
    
42. /*
    
43. * 父类--非静态代码块
    
44. * 父类--构造函数
    
45. */
    
46. //再new ExB()，输出：
    
47. /*
    
48. * 子类--非静态代码块
    
49. * 子类--构造函数
    
50. */
    
51. new ExB();
    
52. }
    
53. }
    
54. 
    
55. class ExB extends ExA {
    
56. private static ExB b = new ExB();
    
57. static {
    
58. System.out.println("子类--静态代码块");
    
59. }
    
60. {
    
61. System.out.println("子类--非静态代码块");
    
62. }
    
63. 
    
64. public ExB() {
    
65. System.out.println("子类--构造函数");
    
66. }
    
67. }
    
68. 
    

复制代码

总结一点：在类加载时先执行static代码，再执行代码块。
在new一个对象时，不用执行static代码了，先执行代码块，然后执行构造方法。

黑马刘杰 发表于 2013-1-13 19:40
总结一点：在类加载时先执行static代码，再执行代码块。
在new一个对象时，不用执行static代码了，先执行代 ...

new一个对象前类不是要先加载好的么

黑马刘杰 发表于 2013-1-13 19:40
总结一点：在类加载时先执行static代码，再执行代码块。
在new一个对象时，不用执行static代码了，先执行代 ...

仔细看了下~懂了~3Q

怎么感觉你的代码很乱的.....我写一个给你看看

1. class Parent
   
2. {
   
3. static
   
4. {
   
5. System.out.println("父类--静态代码块");
   
6. }
   
7. {
   
8. System.out.println("父类--非静态代码块");
   
9. }
   
10. public Parent()
    
11. {
    
12. System.out.println("父类--构造函数");
    
13. }
    
14. }
    
15. 
    
16. class Child extends Parent{
    
17. 
    
18. static
    
19. {
    
20. System.out.println("子类--静态代码块k");
    
21. }
    
22. {
    
23. System.out.println("子类--非静态代码块");
    
24. }
    
25. public Child()
    
26. {
    
27. System.out.println("子类--构造函数");
    
28. }
    
29. }
    
30. 
    
31. public class Test
    
32. {
    
33. public static void main(String[] args)
    
34. {
    
35. new Child();//创建子类对象...
    
36. }
    
37. }
    

复制代码

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

总之一句话，静态代码块内容先执行，接着执行父类非静态代码块和构造方法，然后执行子类非静态代码块和构造方法。

黄金龙 发表于 2013-1-13 20:25
对象的初始化顺序:
首先执行父类静态的内容，父类静态的内容执行完毕后，
接着去执行子类的静态的内容，当 ...

你的代码和我的不一样.......

陈祥厅 发表于 2013-1-13 22:07
你的代码和我的不一样.......

是不一样....但是..我写那个是最简单的初始化.

黄金龙 发表于 2013-1-13 22:33
是不一样....但是..我写那个是最简单的初始化.

目的不是要简单的初始化啊,是要搞明白执行顺序

感觉你代码有点乱..
A类为公开类,并有主方法体了,那B类继承了A类.B类中没有主方法.
你这样继承,那有什么意义呢?  因为A类自身就可以调用自身的成员,B类继承A类 就无意义了.
关于静态初始化块,是在运行public 类时执行的,
除开其他的不说,单说静态初始化块,可以说是看得见的最先执行.

1.主方法存在的类加载进内存,然后开始执行此类的最高级父类中的静态初始化块(如果有的话)
2.所以此类的所有父类中的静态初始化块全部执行完毕后,菜开始非静态初始化块.
    因为,初始化块相当于 构造器的抽象,在通过new调用构造器时,不同形参的构造器如果存在相同
    的执行体,那么就可以把它们放入初始化块中,优先于构造器先执行.
3.因为父类中也可能存在非静态的初始化块,所以所有类中的静态初始化块执行完毕后
    那么就继续从该类的顶级父类中执行非静态初始化块,因为父类中的构造器运行顺序低于本类
    初始化块,但高于子类初始化块.所以顶级父类的非静态初始化块执行完毕后,就直接执行该类中的构造器,
    然后,向下开始依次以相同的方法执行..
4.如果,在主方法中new两个相同子类的对象,那么因为静态初始化块是在加载类时就完毕了,所以不会随着二次new对象来再次执行
    但是,非静态初始化块和,构造器却会随着对象的创建再次执行..

写的有点多.. 应该还算详细吧.