class Fu
{
       Fu(){}——————————1
       Fu(String name)
          {
              System.out.println("name");
           }
        Fu(String name int age)
          {
              System.out.println(name+""+age);
           }
}
class Zi extends Fu
{
          Zi(){}————————2

          Zi(String name)——————3
              {
                 super(name);
               }
          Zi(String name int age)
              {
                  super(name age);
               }
          void run()
              {
                   System.out.println("run");
               }
}
class FuZiDemo1
{
            public static void main(String[] args)
              {
                   new Zi("HeMingHui").run();
               }
}
上述程序中，如果只写子类的默认函数，而不写父类默认的函数，则程序不能通过。我有点想不同，我认为子类集成父类时我已经通过Zi（"HeMingHui"）将父类初始化了啊，是不是我在运行3的时候2也要跟着运行啊，
而且我发现父类的构造函数只可能比子类的多而不能少，这是为什么，难到我总结错误了

new Zi("HeMingHui").run();
java虚拟机执行这句话的时候，
1，new Zi("HeMingHui")
也就是Zi(String name)——————3
              {
                 super(name);
               }
里面有调用父类的构造方法
所以首先调用
Fu(String name)
          {
              System.out.println("name");
           }

所以结果为
name
run

class Fu
{
       Fu(){}——————————1   
       Fu(String name)
          {
              System.out.println("name");
           }
        Fu(String name int age)
          {
              System.out.println(name+""+age);
           }
}
class Zi extends Fu
{
          Zi(){}————————2执行子类的无参构造方法，必须先走父类的无参构造方法，所以不能只写子类默认构造函数

          Zi(String name)——————3执行子类的这个构造方法，要先执行父类的Fu(String name)构造方法
              {
                 super(name);
               }
          Zi(String name int age)
              {
                  super(name age);
               }
          void run()
              {
                   System.out.println("run");
               }
}
class FuZiDemo1
{
            public static void main(String[] args)
              {
                   new Zi("HeMingHui").run();
               }
}

class Fu
{
       Fu(){ super();}——————————1所以这里出现的父类无参构造函数要显示的存在
       Fu(String name)
          {
              System.out.println("name");
           }
        Fu(String name int age)
          {
              System.out.println(name+""+age);
           }
}
class Zi extends Fu
{
          Zi(){super();}————————2子类显示的调用了无参构造函数，其内部隐式调用了父类的无参构造函数，这就要求父类必须要显示调用无参构造函数

          Zi(String name)——————3)调用的是这个构造函数，这个构造函数显示的调用了父类构造函数
              {
                 super(name);
               }
          Zi(String name int age)
              {
                  super(name age);
               }
          void run()
              {
                   System.out.println("run");
               }
}
class FuZiDemo1
{
            public static void main(String[] args)
              {
                   new Zi("HeMingHui").run();在主函数运行的子类是子类有参构造函数
               }
}

package linshi;


class Fu {
        Fu() {
        }


        Fu(String name) {
                System.out.println("name");
        }


        Fu(String name, int age) {
                System.out.println(name + "" + age);
        }
}


class Zi extends Fu {
        Zi() { -------------------------------------------------//默认调用父类中的无参构造函数                                                            
        }


        Zi(String name) {-----------------------------------//调用父类中拥有一个参数的构造函数
                 super(name);
        }


        Zi(String name, int age) {------------------------//调用父类中拥有两个参数的构造函数
                super(name, age);
        }


        void run() {
                System.out.println("run");
        }
}


public class FuZiDemo1 {
        public static void main(String[] args) {
                new Zi("HeMingHui").run();
        }
}

在此根据你的提问我说明两点问题：
1、可能是你不知道子类的无参构造函数调用父类中的无参构造函数。
     说明：
     如果子类中的构造函数没有明确调用父类中的哪个构造函数的时候，都是调用父类的无参构造函数。
     拿此例来讲，如果
     Zi(String name){}和Zi(String name, int age){}在这两个构造函数中都会调用父类中的无参构造函数。
2、可能你认为子类中java虚拟机会提供给子类一个默认的无参构造函数
    说明：
     java虚拟机提供默认的无参构造函数只是当你所写的类中没有构造函数的时候，只有此时，java虚拟机才会给此类加上一个默认的无参构造函数。
     而你写的类中，你已经在子类中写了有参构造函数，所以此时java虚拟机将不会提供默认的无参构造函数，如果你需要一个无参构造函数，需要手动书写。

聂峰 发表于 2012-7-23 16:36
class Fu
{
       Fu(){ super();}——————————1所以这里出现的父类无参构造函数要显示的存在

我认为子类在进行初始化的时候，出现了重载现象啊，那么就会去执行相应的子类构造函数啊，然后通过相应的构造函数中的super()语句后先去去执行父类中的对应的构造函数，那个子类默认函数会去执行到吗

class Fu
{
     //  Fu(){}——————————1
       Fu(String name)
          {
              System.out.println("name");
           }
        Fu(String name int age)
          {
              System.out.println(name+""+age);
           }
}
class Zi extends Fu
{
          Zi(){}————————2
          Zi(String name)——————3
              {
                 super(name);
               }
          Zi(String name int age)
              {
  //super();
                  super(name age);
               }
          void run()
              {
                   System.out.println("run");
               }
}
class FuZiDemo1
{
            public static void main(String[] args)
              {
                   new Zi("HeMingHui").run();
               }
}
上述程序中，如果只写子类的默认函数，而不写父类默认的函数，则程序不能通过。我有点想不同，我认为子类集成父类时我已经通过Zi（"HeMingHui"）将父类初始化了啊，是不是我在运行3的时候2也要跟着运行啊，
而且我发现父类的构造函数只可能比子类的多而不能少，这是为什么，难到我总结错误了


因为Zi类继承了父类的构造函数，所以 Zi(String name int age)
              {
  //super(); 然而在这里有一个隐式的super()语句，而这个隐式的super()语句到父类的找一个空参数的构造函数进行初始化。还有就是父类已经定义了有参数的构造函数，所以那个隐式的空参数构造函数就没有了。所以就必须把空参数的构造函数写上，要不会编译通过。
                  super(name age);
               }
为什么运行3的时候，2也跟着运行。是因为  Zi(String name)——————3
                  {
                     super(name);//这里有一句super会去找父类中带参数的构造器进行初始化。
                                        }
不是说父类的构造函数只能比子类的构造函数少，父类的构造函数也可以很多的。

何明辉 发表于 2012-7-23 17:13
我认为子类在进行初始化的时候，出现了重载现象啊，那么就会去执行相应的子类构造函数啊，然后通过相应的 ...

会被执行到的