A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 周坤 中级黑马   /  2012-7-19 01:26  /  1625 人查看  /  5 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

  1. public class Demo111 {
  2.         public void method(Father f)
  3.         {
  4.                 System.out.println("Father");
  5.         }
  6.         public void method(Son s)
  7.         {
  8.                 System.out.println("Son");
  9.         }
  10.         public static void main(String[] args)
  11.         {
  12.                 Demo111 aa=new Demo111();
  13.                 aa.method(new Father());
  14.                 aa.method(new Son());//去掉public void method(Son s)方法,便会输出Father,为什么?
  15.         }
  16. }
  17. class Father
  18. {
  19. }
  20. class Son extends Father
  21. {
  22. }
复制代码
类Demo111中两个方法应该是重载了,这是编译时多态还是运行时多态?

5 个回复

倒序浏览
本帖最后由 全海波 于 2012-7-19 10:18 编辑
  1. /*
  2. public class Demo111 {

  3.     public void method()
  4.         {
  5.                 System.out.println("--------");
  6.         }
  7.     public void method(Father f)

  8.     {

  9.          System.out.println("Father run.....");

  10.     }
  11.     public void method(Son s)
  12.     {
  13.          System.out.println("Son");
  14.     }
  15.     public static void main(String[] args)

  16.     {

  17.                Demo111 aa=new Demo111();

  18.                            aa.method();

  19.                aa.method(new Father());

  20.                aa.method(new Son());
  21.                            //去掉public void method(Son s)方法,便会输出Father,为什么?
  22.                                 //对于这个问题很简单,你调用了该方法,跟调用一般方法没什么两样
  23.                                 //如:aa.mehtod();
  24.     }

  25. }

  26. class Father

  27. {
  28.         
  29. }

  30. class Son extends Father
  31. {

  32. }
  33. */

  34. /*
  35. 下面用写一个多态示例,仅供参考
  36. */
  37. public class Demo111 {

  38.     public void method()
  39.         {
  40.                 System.out.println("--------");
  41.         }
  42.     public void method(Father f)
  43.     {
  44.                 //向上转型
  45.                  f.show();//编译的时候走的父类方法,运行的时候走的是子类的方法
  46.          System.out.println("Father run.....");

  47.     }
  48.     public void method1(Father fa)
  49.     {
  50.                         //s.show();
  51.                         Son s = (Son)fa;//向下转型
  52.                         s.show();

  53.          System.out.println("Son");

  54.     }
  55.     public static void main(String[] args)

  56.     {

  57.                Demo111 aa=new Demo111();

  58.                            aa.method();
  59.                                 //这个方法当然走的是父类的方法
  60.               // aa.method(new Father());
  61.                           aa.method(new Son());//多态的体现
  62.                                 //同上
  63.               aa.method(new Son());
  64.                         
  65.     }

  66. }
  67. class Father

  68. {
  69.         public void show()
  70.         {
  71.                 System.out.println("^^^^^^^^^^^^^^^^");
  72.         }
  73. }

  74. class Son extends Father
  75. {
  76.         public void show()
  77.         {
  78.                 System.out.println("******&&&&&&");
  79.         }
  80. }
  81. 希望对你有帮助!
复制代码
回复 使用道具 举报
aa.method(new Son());//去掉public void method(Son s)方法,便会输出Father,为什么?

//当去掉public void method(Son s)方法时, aa.method(new Son());就相当于 Father f = new Son()   aa.method(f); 将父类的引用指向子类的对象  所以依然会打印Father
回复 使用道具 举报
类Demo111中两个方法应该不是重载吧,多态的实现依赖于继承来的,多态类其实就是父类的引用来引用子类的对象,但是要调用的方法必须在父类中已经有了,而子类通过继承或者重写父类的方法来实现多态。
回复 使用道具 举报
public class Demo111 {
        public void method(Father f)
        {
                System.out.println("Father");
        }
        public void method(Son s)
        {
                System.out.println("Son");
        }
        public static void main(String[] args)
        {
                Demo111 aa=new Demo111();
                aa.method(new Father());
                aa.method(new Son());//去掉public void method(Son s)方法,便会输出Father,为什么?
                                                 //你的方法又不是定义在类里的,所以只是方法的重载,而Son也是一个Father,
                                                 这是java的多态决定的,所以你去掉了method(son s)的方法,会默认的提升类型,所以也是会有结果的。

        }
}
class Father
{
}
class Son extends Father
{
}
回复 使用道具 举报
多态的三要素:
1. 要有继承
2. 要有重载
3. 要有父类引用指向子类对象
楼主的例子中没有父类引用指向子类对象
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马