黑马程序员技术交流社区

标题: 构造函数 [打印本页]
作者: Saner    时间: 2014-3-28 09:09
标题: 构造函数
class Fu
{
        Fu()
        {
                System.out.println("fu run");
        }
}
class Zi extends Fu
{
        Zi()
        {
                System.out.println("zi run");
        }
        Zi(int x)
        {
                System.out.println("zi..."+x);
        }
}
class ExtendsStudy
{
        public static void main(String[] args)
        {
                Zi z = new Zi();
                Zi z1 = new Zi(3);
        }
}
//如何看这段继承中构造函数的运行情况，给注释一下，谢谢！
作者: 林发明    时间: 2014-3-28 10:11
  1. class Fu
  2. {
  3.         Fu()
  4.         {
  5.                 System.out.println("fu run");
  6.         }
  7. }
  8. class Zi extends Fu
  9. {
  10.         Zi()
  11.         {
  12.                         //super();子类构造函数第一行中都有一个隐式的父类构造函数super()，这里的super()等同于Fu();
  13.                                                 //所以在执行子类构造函数时都会执行父类的这个隐式构造函数
  14.                 System.out.println("zi run");
  15.         }
  16.         Zi(int x)
  17.         {
  18.                         //super();//同上面
  19.                 System.out.println("zi..."+x);
  20.         }
  21. }
  22. class ExtendsStudy
  23. {
  24.         public static void main(String[] args)
  25.         {
  26.                 Zi z = new Zi();//执行过程Fu()-->Zi()
  27.                 Zi z1 = new Zi(3);//执行过程Fu()-->Zi(int x)
  28.         }
  29. }

复制代码


打印结果：
fu run
zi run
fu run
zi...3
作者: show_play    时间: 2014-3-29 01:08
        从2楼的代码可以清楚的看出，子类对象在实例化前会默认调用父类中的构造函数。就好像没有父亲就没有孩

子，所以在实例化子类对象前需要先将父类中的属性进行初始化。当然，你的代码实际上在子类的构造方法中隐含了

一个super()的语法。                                         //你不加也没有关系。java自动帮你加。
作者: 我叫MT    时间: 2014-3-29 20:39
一个有参的，一个无参的，具体他会调用看你传不传参数或传入什么类型的参数
作者: wuyuecns    时间: 2014-3-30 18:51
其实这个代码里面用到了方法的重载，方法名相同，一个有参数，一个没有
作者: 蒋珍珍    时间: 2014-3-31 09:51

  2. class Fu
  3. {
  4.         Fu()//无参构造器
  5.         {
  6.                 System.out.println("fu run");
  7.         }
  8. }
  9. class Zi extends Fu
  10. {
  11.         /*因为这个类Zi继承了Fu类，所以当new一个Zi类对象的时候，就会首先去调用父类中的默认构造方法（无参数构造器）
  12.          * 如果父类中没有定义默认构造器的话，就需要在子类中显示调用父类中的其他有参构造器。
  13.          * */
  14.         Zi()
  15.         {
  16.                 //super();此处隐藏了super方法，隐式调用父类的无参数构造器
  17.                 System.out.println("zi run");
  18.         }
  19.         Zi(int x)//它重载了默认的构造函数
  20.         {
  21.                 //super();此处也隐藏了super方法，隐式调用父类的无参数构造器
  22.                 System.out.println("zi..."+x);
  23.         }
  24. }
  25. class Z
  26. {
  27.         public static void main(String[] args)
  28.         {
  29.                 Zi z = new Zi();//会调用无参构造函数
  30.                 Zi z1 = new Zi(3);//会调用有参构造函数
  31.         }
  32. }
复制代码

如果你还不明白的话，你可以设置断点，自己逐步调试一下，然后你就明白它的先后调用顺序了，加油



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2