“问题已经解决”。

class classC extends classA
{
public classC()
{
         System.out.println("C");
        }
}


class classA
{
public classA()
{
         System.out.println("A");
        }
}


class classB extends classC
{
public classB()
{
  System.out.println("B");
}
}


public class Test
{
public static void main(String args[])
{
  System.out.println("Main");
  classB c = new classB();
}
}
打印结果为:
Main
A
C
B
先是主函数能看明白，后面的为什么不是B而是A啊，就不懂了。有高手分析下。

给你看看这些代码，看明白了，你也就懂了

1. package com.hf.scjp.constructor;
   
2. 
   
3. public class Parent1 {
   
4. public static StaticTest stat=new StaticTest(1L);
   
5. static {
   
6.   
   
7.     System.out.println("in parent1 static code …… ");
   
8. }
   
9.    public Parent1(){
   
10.     System.out.println("in parent1 constructor …… ");
    
11.    
    
12.    }
    
13. }
    
14. 
    
15. 
    
16. 
    
17. 
    
18. 
    
19. 
    
20. 
    
21. package com.hf.scjp.constructor;
    
22. 
    
23. public class Son1 extends Parent1 {
    
24. public static StaticTest stat=new StaticTest(1);
    
25. static {
    
26.   
    
27.     System.out.println("in Son1 static code …… ");
    
28. }
    
29. public Son1(){
    
30.      System.out.println("in Son1 constructor …… ");
    
31.      
    
32.     }
    
33. public Son1(int s){
    
34.      System.out.println("in Son1 constructor with param: int");
    
35.      
    
36.     }
    
37. 
    
38. }
    
39. 
    
40. 
    
41. package com.hf.scjp.constructor;
    
42. 
    
43. public class GrandChild1  extends Son1{
    
44. public static StaticTest stat=new StaticTest();
    
45. static {
    
46.   
    
47.     System.out.println("in GrandChild1 static code …… ");
    
48. }
    
49. public GrandChild1(){
    
50.      System.out.println("in GrandChild1 constructor …… ");
    
51.      
    
52.     }
    
53. public GrandChild1(String s){
    
54.      System.out.println("in GrandChild1 constructor with param: String");
    
55.      
    
56.     }
    
57. public GrandChild1(int s){
    
58.      super(s);
    
59.      
    
60.      System.out.println("in GrandChild1 constructor with param: int");
    
61.      
    
62. }
    
63. public GrandChild1(long s){
    
64.      this((int)s);
    
65.      
    
66.      System.out.println("in GrandChild1 constructor with param: long");
    
67.      
    
68. }
    
69. public static void main(String[] args){
    
70.   GrandChild1 GrandChild1=new GrandChild1("");
    
71.    System.out.println("\n\r");
    
72.   
    
73.   GrandChild1 GrandChild2=new GrandChild1(3);
    
74.   
    
75.    System.out.println("\n\r");
    
76.   GrandChild1 GrandChild3=new GrandChild1(3L);
    
77. }
    
78. }
    
79. 
    
80. public class StaticTest {
    
81.     public StaticTest(){
    
82.      System.out.println("in StaticTest constructor param:  ");
    
83.      
    
84.     }
    
85.     public StaticTest(int i){
    
86.      System.out.println("in StaticTest constructor param:int  ");
    
87.      
    
88.     }
    
89.     public StaticTest(long l){
    
90.      System.out.println("in StaticTest constructor param:long  ");
    
91.      
    
92.     }
    
93. /**
    
94.   * @param args
    
95.   */
    
96. public static void main(String[] args) {
    
97.   // TODO 自动生成方法存根
    
98. 
    
99. }
    
100. 
     
101. }
     
102. 
     
103. //这是一个三个类之间的继承关系继承：在孙子类中定义了main并创建三个孙子类对象，分别调用不同的构造函数，执行结果如下：
     
104. in StaticTest constructor param:long  
     
105. in parent1 static code ……
     
106. in StaticTest constructor param:int  
     
107. in Son1 static code ……
     
108. in StaticTest constructor param:  
     
109. in GrandChild1 static code ……
     
110. in parent1 constructor ……
     
111. in Son1 constructor ……
     
112. in GrandChild1 constructor with param: String
     
113. 
     
114. 
     
115. 
     
116. in parent1 constructor ……
     
117. in Son1 constructor with param: int
     
118. in GrandChild1 constructor with param: int
     
119. 
     
120. 
     
121. 
     
122. in parent1 constructor ……
     
123. in Son1 constructor with param: int
     
124. in GrandChild1 constructor with param: int
     
125. in GrandChild1 constructor with param: long

复制代码

这说明：
1 类中的静态对象先于static{}执行
2  static{}中的代码是在构建类对象之前执行的
3 构造子类的时候是按照先父后子的顺序执行的
4 如果在子的构造函数中并没有使用显式的调用父类的构造函数（使用super），则执行无参构造函数。
5 如果使用this(),则会先调用this(),再调用下面的代码(此时父类别的默认构造函数不再执行,而会根据执行this()执行相应的父构造函数)
说的自己都晕了，还是看代码来的简单容易

子类继承父类，当创建子类对象时需要先创建父类对象，当你new B()对象时，默认在B类的构造函数中的第一行调用了super(),也就调用了父类的构造函数，同理调用父类的父类，所谓有父亲才有儿子的道理。所以执行的结果就是这个样子。但是要切记构造函数不能继承，只能在子类的构造函数中隐式或显示的调用（可以使用super关键字）

  以classA，classB，classC命名有点让人蛋疼啊，容易让人弄混，其实原理很简单，就是B-->C-->A的继承关系，如图所示，点开看看就知道了
在输出main后 最后输出结果由上往下是ACB

因为构造函数如果第一跳条语句没有写this或super，系统会默认添加一天super（）
分析：System.out.println("Main");
  classB c = new classB();
首先输出打印 Main
然后创建一个B类对象，使用的是无参构造函数
public classB(){  System.out.println("B"); }
它的第一条语句不是this也不是指定的super，所以系统默认生成super();
执行super()找B的直接父类，super()没执行完后面的语句是不会运行，然后找到他的夫类C类，调用C类的无参构造函数，
public classC(){  System.out.println("C"); }
它的第一条语句也不是this和指定的super，所以系统默认生成super();执行super()找C的直接父类，调用A类的无参构造函数
public classA(){  System.out.println("A"); }
它的第一条语句也不是this和指定的super，所以系统默认生成super();执行super()找A的直接父类，A类无直接父类，默认继承了Object类
这里就就会完成A类的构造，输出A， A类执行完成后C类执行后续操作 输出C C构造完成后B类也执行后面操作 输出B
所以最终的打印结果是：
Main
A
C
B

好几个错别字{:soso_e110:}