class HelloA {
    public HelloA() {
        System.out.println("HelloA");
    }
   
    { System.out.println("I'm A class"); }
   
    static { System.out.println("static A"); }

}

public class HelloB extends HelloA {
    public HelloB() {
        System.out.println("HelloB");
    }
   
    { System.out.println("I'm B class"); }
   
    static { System.out.println("static B"); }
   
    public static void main(String[] args) {
　　　　 new HelloB();
　　 }
}
问：输出结果是什么
这段代码很好地考察了静态语句块、构造语句块及构造函数的执行顺序，之前貌似弄清楚了，不过最近又看到这种题目，又做错了，请教分析它们的执行顺序，谢谢。
顺便为了考察下各位，我就先不贴答案，让大家也巩固一下相关知识

先静态再构造最后构造函数，应该是static A， I'm A class，HelloA，static B，I'm B class，HelloB     电脑坏了再修，先标记个以后再验证

1. package com.itcast.day01;
   
2. /*
   
3. * 首先你要明白代码块、静态代码块、构造代码块的执行顺序：
   
4. * 静态代码块是用来给类初始化用的，类加载的同时，静态代码块就加载了
   
5. * 代码块是用来给对象初始化的
   
6. * 构造函数还有必要说吗？
   
7. *
   
8. * 这里又涉及到继承的问题，子类的构造函数默认的第一行有一句隐式的super()，
   
9. * 所以建立子类对象的时候，父类中的代码块和构造函数优先于子类的代码块和构造函数运行了
   
10. */
    
11. class HelloA {
    
12.         //HelloA的构造函数
    
13.         public HelloA() {
    
14.                 System.out.println("HelloA的构造函数");
    
15.         }
    
16.         //代码块
    
17.         {
    
18.                 System.out.println("I'm A 的代码块");
    
19.         }
    
20.         //静态代码块
    
21.         static {
    
22.                 System.out.println("static A 的静态代码块");
    
23.         }
    
24. }
    
25. //HelloA的子类HelloB
    
26. public class HelloB extends HelloA {
    
27.         //HelloB的构造函数
    
28.         public HelloB() {
    
29.                 System.out.println("HelloB的构造函数");
    
30.         }
    
31.         //代码块
    
32.         {
    
33.                 System.out.println("I'm B 的代码块");
    
34.         }
    
35.         //静态代码块
    
36.         static {
    
37.                 System.out.println("static B 的静态代码块");
    
38.         }
    
39. 
    
40.         public static void main(String[] args) {
    
41.                 //建立子类对象
    
42.                 new HelloB();
    
43.         }
    
44. }

复制代码

少侠，答案就在代码中的注释里面，还需要我再详细的解答吗？

运行的结果如下：

static A 的静态代码块
static B 的静态代码块
I'm A 的代码块
HelloA的构造函数
I'm B 的代码块
HelloB的构造函数

加载顺序：先静态后非静态。静态：静态变量，静态代码块。他们执行的优先级相同。非静态：构造代码块，变量，构造函数

static A 的静态代码块

static B 的静态代码块

I'm A 的代码块

HelloA的构造函数

I'm B 的代码块

HelloB的构造函数
总结:1.先父类静态
2.再子类静态
3.再父类构造代码块
4.再父类构造函数
5.再子类构造代码块
6再子类构造函数

夏季熬成了秋 发表于 2014-6-11 00:39
static A 的静态代码块

static B 的静态代码块

总结的…通俗易懂

静态代码块，构造代码块，构造函数，
先父类，后子类

都很厉害啊！我也得努力了！！！

夏季熬成了秋 发表于 2014-6-11 00:39
static A 的静态代码块

static B 的静态代码块

父类代码块-->子类代码块-->父类构造函数-->子类构造函数，这个跟你给的答案好像有点不符。
我觉得应该是：父类代码块-->父类构造函数-->子类代码块-->子类构造函数

love~陌 发表于 2014-6-10 23:44
少侠，答案就在代码中的注释里面，还需要我再详细的解答吗？

运行的结果如下：

很好很详细，谢谢

IStudying 发表于 2014-6-10 23:28
先静态再构造最后构造函数，应该是static A， I'm A class，HelloA，static B，I'm B class，HelloB     电 ...

嗯，一起学习，可以看下本帖的其他解答

完全是来学习的！

sam9204 发表于 2014-6-11 09:03
嗯，一起学习，可以看下本帖的其他解答

哦哦，原来如此

sam9204 发表于 2014-6-11 08:58
父类代码块-->子类代码块-->父类构造函数-->子类构造函数，这个跟你给的答案好像有点不符。
我觉得应该是 ...

对对,昨晚太累了  没看清.,马虎了....不好意思哈.

夏季熬成了秋 发表于 2014-6-11 00:39
static A 的静态代码块

static B 的静态代码块

修正了哈.