黑马程序员技术交流社区

标题: 问题，绝不是刷分！！！！ [打印本页]
作者: 全海波    时间: 2012-7-13 19:14
标题: 问题，绝不是刷分！！！！
本帖最后由 全海波 于 2012-8-4 09:44 编辑
  1. class FuZi
  2. {
  3.         public static void main(String[] args)
  4.         {
  5.                 Zi z = new Zi();
  6.                 //z.function();
  7.                 z.show();
  8.                 Fu f = new Zi();
  9.                 f.show();
  10.         }
  11. }
  12. class Fu
  13. {
  14.         void show()
  15.         {
  16.                 System.out.println("fu show");
  17.         }
  18. }
  19. class Zi extends Fu
  20. {
  21.         /*
  22.         void function()
  23.         {
  24.         }
  25.         */
  26.         void show()
  27.         {
  28.                 System.out.println("zi show");
  29.         }
  30. }
复制代码
问这个类的执行顺序？
作者: 苑占丽    时间: 2012-7-13 19:31
01.class FuZi

02.{

03.        public static void main(String[] args)

从这开始读程序04.        {

05.                Zi z = new Zi();1，创建一个子类对象

06.                //z.function();

07.                z.show();2，调用子类方法，因为当子类复写了父类的方法时，会调用子类的所以此时输出一个zi show

08.                Fu f = new Zi();涉及到多态，创建一个子类对象，让父类变量去引用

09.                f.show();4，此时编译看左边，运行看右边这句话就起作用了，当然还是调用子类的show方法，输出zi show，程序执行完毕

10.        }

11.}

12.class Fu

13.{

14.        void show()

15.        {

16.                System.out.println("fu show");

17.        }

18.}

19.class Zi extends Fu

20.{

21.        /*

22.        void function()

23.        {

24.        }

25.        */

26.        void show()

27.        {

28.                System.out.println("zi show");

29.        }

30.}
希望你看懂了
作者: 王飞    时间: 2012-7-13 19:59
class FuZi
{
        public static void main(String[] args)     
        {
                Zi z = new Zi();---------------------------------------------------------，先去执行Zi的无参构造函数，因为没个构造函数的第一行都默认有super()，所以程序就去调用父类的无参构造函数，因为父类默认无参构造函数没有要执行的代码，于是这行代码就执行完了
                //z.function();
                z.show();  ---------------------------此时调用子类的show()方法，打印 zi show
                Fu f = new Zi();  -------------- 这是多态方面内容，一个父类引用指向了一个子类对象，
                 
                f.show();  ------------------------此时执行的这个show()是zi的方法而不是fu类的show()方法，因为编译看左边，执行看右边，所以打印的是 zi show
        }
}
class Fu
{
        void show()
        {
                System.out.println("fu show");
        }
}
class Zi extends Fu
{
        /*
        void function()
        {
        }
        */
        void show()
        {
                System.out.println("zi show");
        }
}
作者: 郑璋安    时间: 2012-7-13 20:25
本帖最后由 郑璋安 于 2012-7-13 20:29 编辑

  1. public class FuZi {

  3.         public static void main(String[] args) {
  4.                 Zi z1 = new Zi();
  5.                 System.out.println("-------------------------------");
  6.                
  7.                 Zi z2 = new Zi(3);        
  8.                 z2.show();
  9.                
  10.                 System.out.println("-------------------------------");

  12.                 Fu f = new Zi(4);

  14.                 f.show();

  16.         }

  18. }

  20. class Fu

  22. {
  23.         Fu(){
  24.                 System.out.println("Fu()");        [color=Red]//------3------        //第2次创建Zi对象时------7------[/color]
  25.         }
  26.         Fu(int i) {
  27.                 System.out.println("Fu(" + i + ")");        [color=Red]//-------8------
  28. [/color]        }

  30.         void show()

  32.         {

  34.                 System.out.println("fu show()");

  36.         }

  38. }

  40. class Zi extends Fu
  41. {
  42.         private Fu fu1= new Fu(1);        [color=Red]//------4------[/color]
  43.         private static Fu fu2 = new Fu(2);        [color=Red]//-------1------
  44. [/color]        Zi(){
  45.                 System.out.println("Zi()");        [color=Red]//------6------
  46. [/color]        }
  47.         Zi(int i) {
  48.                 System.out.println("Zi(" + i +")" );        [color=Red]//------10------
  49. [/color]        }
  50.         
  51.         public static void function() {
  52.                 System.out.println("function()");
  53.         }
  54.          
  55.         public void show()

  57.         {

  59.                 System.out.println("zi show()");        [color=Red]//------11------        由于子类覆盖了父类show()方法，多态机制就能够保证真正对象即Zi的show方法被调用[/color]

  61.         }
  62.         
  63.         {
  64.                 System.out.println("Zi的非静态代码块");        [color=Red]//------5------        //第2次创建Zi对象时------9------
  65. [/color]        }
  66.         static {
  67.                 System.out.println("Zi的静态代码块");        [color=Red]//------2------        //第2次创建Zi对象时这里没执行了，因为Zi.class文件已经加载到了内存中，而静态代码块只执行一次
  68. [/color]        }

  70. }
  71. /**输出结果为：
  72. Fu(2)
  73. Zi的静态代码块
  74. Fu()
  75. Fu(1)
  76. Zi的非静态代码块
  77. Zi()
  78. -------------------------------
  79. Fu()
  80. Fu(1)
  81. Zi的非静态代码块
  82. Zi(3)
  83. zi show()
  84. -------------------------------
  85. Fu()
  86. Fu(1)
  87. Zi的非静态代码块
  88. Zi(4)
  89. zi show()
  90. */
  91. 上面是我根据楼主的示例编写的一个展示Java中静态成员、非静态成员、子父类有参无参构造方法等执行顺序的代码，从输出中就可看到执行顺序，供楼主参考下。
复制代码
作者: 谭培龙    时间: 2012-7-13 21:11
  1. class FuZi
  2. {
  3.         public static void main(String[] args)
  4.         {
  5.                 Zi z = new Zi();//new了一个子类对象
  6.                 //z.function();
  7.                 z.show();//调用子类的show方法。
  8.                 Fu f = new Zi();//用父类引用指向子类对象，这个是多态的表现形式。
  9.                 f.show();//因为父类的show方法被子类复写，所以调用子类的show方法。
  10.         }
  11. }
  12. class Fu
  13. {
  14.         void show()//父类的show方法
  15.         {
  16.                 System.out.println("fu show");
  17.         }
  18. }
  19. class Zi extends Fu
  20. {
  21.         /*
  22.         void function()
  23.         {
  24.         }
  25.         */
  26.         void show()//子类复写了父类的show方法
  27.         {
  28.                 System.out.println("zi show");
  29.         }
  30. }
  31. 所以结果是
复制代码




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