1. class Root {
   
2.     static {
   
3.         System.out.println("Root的静态初始化块");
   
4.     }
   
5.     {
   
6.         System.out.println("Root的普通初始化块");
   
7.     }
   
8. 
   
9.     public Root() {
   
10.         System.out.println("Root的无参数的构造器");
    
11.     }
    
12. }
    
13. 
    
14. class Mid extends Root {
    
15.     static {
    
16.         System.out.println("Mid的静态初始化块");
    
17.     }
    
18.     {
    
19.         System.out.println("Mid的普通初始化块");
    
20.     }
    
21. 
    
22.     public Mid() {
    
23.         System.out.println("Mid的无参数的构造器");
    
24.     }
    
25. 
    
26.     public Mid(String msg) {
    
27.         this();
    
28.         System.out.println("Mid的带参数构造器，其参数值：" + msg);
    
29.     }
    
30. }
    
31. 
    
32. class Leaf extends Mid {
    
33.     static {
    
34.         System.out.println("Leaf的静态初始化块");
    
35.     }
    
36.     {
    
37.         System.out.println("Leaf的普通初始化块");
    
38.     }
    
39. 
    
40.     public Leaf() {
    
41.         super("测试语句");
    
42.         System.out.println("执行Leaf的构造器");
    
43.     }
    
44. }
    
45. 
    
46. public class Test {
    
47.     public static void main(String[] args) {
    
48.         new Leaf();
    
49.         new Leaf();
    
50.     }
    
51. }<p></p>

复制代码

结果是：
Root的静态初始化块
Mid的静态初始化块
Leaf的静态初始化块
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器，其参数值：测试语句
Leaf的普通初始化块
执行Leaf的构造器
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器，其参数值：测试语句
Leaf的普通初始化块
执行Leaf的构造器

静态代码块优先加载~~~

空洞的望着窗外 发表于 2015-3-9 23:02
静态代码块优先加载~~~

为啥普通初始化块也在构造函数前运行

有那么复杂吗

类一加载静态代码块就出来了，只执行一次，然后每new一个对象代码块运行，然后是构造函数

静态语句快在类加载的时候就加载进来，只有一次，普通语句快和 构造方法是new对象的时候才有

我也是有点晕晕的

静态代码块随着类的加载而加载，所以不管是父类的或是子类的静态代码块都会先运行

我先给你分析一下我写的程序，然后再看你的。你可能就会明白了

1. public class Day08_1{

复制代码

最后的执行顺序是这样的* 代码块的执行顺序
* 1.Day08_1的静态代码块执行了
2.main函数执行了
3.Student的静态代码块执行了
4.构造代码块执行了
5.构造函数执行了
6.构造代码块执行了
分析：当JVM要想执行一个程序时，1.首先要找main方法，于是Day_8类就加载到了内存，静态代码块是一个类加载到内存时执行的，也就是类初始化的。所以1.Day08_1的静态代码块执行了第一个执行；2.接着main方法执行,于是2.main函数执行了执行了;3.接着new Student（）时，Student类加载到了内存，所以3.Student的静态代码块执行了（并且只执行一次）；4，接着new Sutdent()时，｛｝括起来的是对象初始化代码块，里面都是所有对象共有的内容，先于构造函数执行，所以构造代码块执行了，（并且每次调构造函数都会执行）；5.构造函数执行了；6.构造代码块执行了

android-liu 发表于 2015-3-10 23:22
我先给你分析一下我写的程序，然后再看你的。你可能就会明白了最后的执行顺序是这样的* 代码块的执行顺序[/ ...

首先谢谢你的解答，好像代码不全吧，只看到了第一行。。。

1. package com.xiangying;
   
2. 
   
3. public class Day08_1 {
   
4. 
   
5.         /**
   
6.          * 代码块的执行顺序
   
7.          *  1.Day08_1的静态代码块执行了
   
8.                 2.main函数执行了
   
9.                 3.Student的静态代码块执行了
   
10.                 4.构造代码块执行了
    
11.                 5.构造函数执行了
    
12.                 6.构造代码块执行了
    
13.          */
    
14.        
    
15.         public static void main(String[] args) {
    
16.                 System.out.println("main函数执行了");
    
17.                 Student s=new Student();
    
18.                 Student s1=new Student();
    
19. 
    
20.         }
    
21. static {
    
22.                
    
23.                 System.out.println("Day08_1的静态代码块执行了");
    
24.         }
    
25. 
    
26. }
    
27. class Student{
    
28.         {
    
29.                 System.out.println("构造代码块执行了");
    
30.                
    
31.         }
    
32.         static{
    
33.                 System.out.println("Student的静态代码块执行了");
    
34.         }
    
35. 
    
36.         public Student(){
    
37.                 System.out.println("构造函数执行了");
    
38.         }
    
39.        
    
40.        
    
41.        
    
42. }

复制代码