黑马程序员技术交流社区

标题: 多态的问题 [打印本页]
作者: 周坤    时间: 2012-7-19 01:26
标题: 多态的问题
  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中两个方法应该是重载了，这是编译时多态还是运行时多态？
作者: 全海波    时间: 2012-7-19 06:57
本帖最后由 全海波 于 2012-7-19 10:18 编辑
  1. /*
  2. public class Demo111 {

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

  10.     {

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

  14.     }
  15.     public void method(Son s)
  16.     {
  17.          System.out.println("Son");
  18.     }
  19.     public static void main(String[] args)

  21.     {

  23.                Demo111 aa=new Demo111();

  25.                            aa.method();

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

  29.                aa.method(new Son());
  30.                            //去掉public void method(Son s)方法，便会输出Father，为什么？
  31.                                 //对于这个问题很简单，你调用了该方法，跟调用一般方法没什么两样
  32.                                 //如：aa.mehtod();
  33.     }

  35. }

  37. class Father

  39. {
  40.         
  41. }

  43. class Son extends Father
  44. {

  46. }
  47. */

  49. /*
  50. 下面用写一个多态示例，仅供参考
  51. */
  52. public class Demo111 {

  54.     public void method()
  55.         {
  56.                 System.out.println("--------");
  57.         }
  58.     public void method(Father f)
  59.     {
  60.                 //向上转型
  61.                  f.show();//编译的时候走的父类方法，运行的时候走的是子类的方法
  62.          System.out.println("Father run.....");

  64.     }
  65.     public void method1(Father fa)
  66.     {
  67.                         //s.show();
  68.                         Son s = (Son)fa;//向下转型
  69.                         s.show();

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

  73.     }
  74.     public static void main(String[] args)

  76.     {

  78.                Demo111 aa=new Demo111();

  80.                            aa.method();
  81.                                 //这个方法当然走的是父类的方法
  82.               // aa.method(new Father());
  83.                           aa.method(new Son());//多态的体现
  84.                                 //同上
  85.               aa.method(new Son());
  86.                         
  87.     }

  89. }
  90. class Father

  92. {
  93.         public void show()
  94.         {
  95.                 System.out.println("^^^^^^^^^^^^^^^^");
  96.         }
  97. }

  99. class Son extends Father
  100. {
  101.         public void show()
  102.         {
  103.                 System.out.println("******&&&&&&");
  104.         }
  105. }
  106. 希望对你有帮助！
复制代码
作者: 孙建飞    时间: 2012-7-21 20:26
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
作者: 王贵朝    时间: 2012-7-21 21:03
类Demo111中两个方法应该不是重载吧，多态的实现依赖于继承来的，多态类其实就是父类的引用来引用子类的对象，但是要调用的方法必须在父类中已经有了，而子类通过继承或者重写父类的方法来实现多态。
作者: 封明川    时间: 2012-7-21 21:49
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
{
}
作者: 张水荣    时间: 2012-7-21 21:52
多态的三要素：
1. 要有继承
2. 要有重载
3. 要有父类引用指向子类对象
楼主的例子中没有父类引用指向子类对象




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