1.   class Parent {
   
2. 
   
3.           public static String p_StaticField = "父类--静态变量";
   
4.           public String p_Field = "父类--变量";
   
5.           static {
   
6.                   System.out.println(p_StaticField);
   
7.                   System.out.println("父类--静态初始化块");
   
8.           }
   
9.           {
   
10.                   System.out.println(p_Field);
    
11.                   System.out.println("父类--初始化块");
    
12.           }
    
13.           public Parent() {
    
14.                    System.out.println("父类--构造器");
    
15.            }
    
16.   }
    
17.   public class SubClass extends Parent {
    
18.           public static String s_StaticField = "子类--静态变量";
    
19.            public String s_Field = "子类--变量";
    
20.            static {
    
21.                    System.out.println(s_StaticField);
    
22.                    System.out.println("子类--静态初始化块");
    
23.            }
    
24.            {
    
25. 
    
26.                    System.out.println(s_Field);
    
27. 
    
28.                    System.out.println("子类--初始化块");
    
29. 
    
30.            }
    
31.            public SubClass() {
    
32.                    System.out.println("子类--构造器");
    
33.            }
    
34.            public static void main(String[] args) {
    
35.                    new SubClass();
    
36.            }
    
37.   }
    

复制代码

有哪位亲帮我看看这题目的运行结果吗  并帮我分析分析

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

父类静态代码块 ——>子类静态代码块 ——>  父类的非静态构造代码块 ——>  父类的构造方法——> 子类的非静态代码块 ——> 子类构造方法

父类--静态变量
父类--静态初始化块
子类--静态变量
子类--静态初始化块
父类--变量
父类--初始化块
父类--构造器
子类--变量
子类--初始化块
子类--构造器
分析：
静态先执行，随着类的创建而加载，优先于对象先存在。
随后是构造代码块执行。
然后是构造函数执行。
子类继承父类。先执行父类程序，在执行子类程序。
静态>构造代码块>构造函数
父类>子类
子类静态>父类构造代码块

邓斌 发表于 2012-4-11 20:16
父类--静态变量
父类--静态初始化块
子类--静态变量

懂了。。。很明白

邓斌 发表于 2012-4-11 20:16
父类--静态变量
父类--静态初始化块
子类--静态变量

懂了。。。很明白很清楚