public class Test {
                  public static void main(String[] args){
                          B b=new B("test");
                  }
         }
class B extends Aq{
        B(String s){
                System.out.println(s);
        }
        B(String s,String t){
                this(t+s+"3");
        }
        B(){
                super("4");
        }
}
        class Aq{
                Aq(String s){
                        System.out.println(s);
                }
                Aq(String s,String t){
                        this(s+t);
                }
                Aq(){
                        this("1","2");
                }
        }
该程序输出的结果是：
12
test
为什么结果不是 test，该程序是如何执行的？

public class Test {
                  public static void main(String[] args){
                          B b=new B("test");
                  }
         }
class B extends Aq{
        B(String s){
             //这里会有一个隐式的super();   //第一步
             System.out.println(s);//第五步
   }
        B(String s,String t){
             this(t+s+"3");
        }
        B(){
                super("4");
        }
}
        class Aq{
                Aq(String s){//第四步
                        System.out.println(s);
                }
                Aq(String s,String t){//第三步
                      this(s+t);
                }
                Aq(){   //第二步
                        this("1","2");
                }
        }

呵呵  同意楼上那位的顺序，补充下：第一步之前还有一步就是根据传入的参数个数寻找相应的有参数的构造函数，这么才能进入程序的执行，如果 B b=new B() 里面不加参数那么就会编译失败的   之后才是第一步调用第二步  第二步调用第三步  第三步调用第四步 这个是重载的典型应用，同一个类中方法与方法之间的调用 所以这四步只会输出第四步的执行语句。
第5步就很容易理解了

public class Test {
                   public static void main(String[] args){
                           B b=new B("test"); //第一步：创建对象，调用B中带有一个参数的构造方法
                   }
          }
class B extends Aq{
         B(String s){
                 super();//第二步：因为B类继承Aq，所以会隐式调用Aq的午餐构造方法
                 System.out.println(s);//第六步：打印出s的值，注意是第一步传递过来的值，为test
         }
         B(String s,String t){
                 this(t+s+"3");
         }
         B(){
                 super("4");
         }
}
         class Aq{
                 Aq(String s){
                         System.out.println(s);//第五步：打印s的值，也就是传递过来的值为：12
                 }
                 Aq(String s,String t){
                         this(s+t);//第四步：s+t只是一个字符串，所以调用本类的带有一个字符串的构造方法。
                 }
                 Aq(){
                         this("1","2");//第三步:调用本类的带有两个参数的构造方法
                 }
         }

好像是的 也就是说 在main函数执行 后 到达 ” B(String s){“中的 super();方法，之后执行了Aq类 ，
      是不是每个构造方法中都有 super();?

孙传磊 发表于 2013-3-1 19:09
好像是的 也就是说 在main函数执行 后 到达 ” B(String s){“中的 super();方法，之后执行了Aq类 ，
      ...

是的,所有类都继承自Object..

孙传磊 发表于 2013-3-1 19:09
好像是的 也就是说 在main函数执行 后 到达 ” B(String s){“中的 super();方法，之后执行了Aq类 ，
      ...

如果构造函数中有this关键字，那么就不会有super了，因为这两个关键字都必须要在第一行才有效

.▂_V 发表于 2013-3-1 21:15
如果构造函数中有this关键字，那么就不会有super了，因为这两个关键字都必须要在第一行才有效 ...

O(∩_∩)O谢谢

孙传磊 发表于 2013-3-2 09:52
O(∩_∩)O谢谢

谢完了记得改帖子哦~  这回帮你改了~

嗯呢！抱歉哈！之前不知要改贴！