黑马程序员技术交流社区

标题: 继承问题求助 [打印本页]
作者: uu993    时间: 2014-6-9 20:36
标题: 继承问题求助
  学完继承之后，看到两种继承的表达形式，但是自己没有看明白，不知道这两种方式有什么区别；
第一种：Animal a=new Dog()；第二种： Dog d=(Dog)a。


比如说：
Animal的方法：睡觉，叫
Dog的方法：摇尾巴
那么 a中能有的方法应该就是： （Dog）睡觉，(Dog)叫，而不能摇尾巴

那么第二种，d中的方法是什么呢
作者: SyouRai_Tsk    时间: 2014-6-9 20:52
睡觉，叫，摇尾巴
作者: uu993    时间: 2014-6-9 20:56
SyouRai_Tsk 发表于 2014-6-9 20:52
睡觉，叫，摇尾巴

可以详细一点吗~
作者: 付江涛    时间: 2014-6-9 21:02
强制转换吧
作者: idency    时间: 2014-6-9 21:12
你这个问题是多态,多态的前提之一是重写,你的方法不存在重写啊
作者: uu993    时间: 2014-6-9 21:32
付江涛 发表于 2014-6-9 21:02
强制转换吧

嗯，是强制转化
作者: 黑马粉、峥    时间: 2014-6-9 21:42
多态
对象在不同时刻表现出来的不同状态（对于引用类型，有两个状态：编译期状态、运行期状态）
实现多态的前提：需要存在继承或者实现关系；需要有方法重写；由父类引用指向子类对象
格式：父类 变量名=new 子类（）；
  1. class Animal
  2. {
  3.         public Animal(){}

  5.         public void show()
  6.         {
  7.                 System.out.println("Animal show");
  8.         }

  10.         public void eat()
  11.         {
  12.                 System.out.println("Animal eat");
  13.         }
  14. }

  16. class Dog extends Animal
  17. {
  18.         public void show()
  19.         {
  20.                 System.out.println("Dog show");
  21.         }
  22.         public void eat()
  23.         {
  24.                 System.out.println("Dog eat bone");
  25.         }

  27.         public void say()
  28.         {
  29.                 System.out.println("I'm Dog");
  30.         }

  32. }

  34. class Cat extends Animal
  35. {
  36.         public void show()
  37.         {
  38.                 System.out.println("Cat show");
  39.         }
  40.         public void eat()
  41.         {
  42.                 System.out.println("Cat eat fish");
  43.         }
  44.         public void say()
  45.         {
  46.                 System.out.println("I'm Cat");
  47.         }

  49. }
  50. class AnimalTool
  51. {
  52.         public static void print(Animal animal)
  53.         {
  54.                 animal.show();
  55.                 animal.eat();
  56.         }
  57. }
  58. class AnimalTest
  59. {
  60.         public static void main(String[] args)
  61.         {
  62.                 Animal a=new Dog();//向上转型
  63.                 Animal b=new Cat();//向上转型
  64.                 AnimalTool.print(a);
  65.                 AnimalTool.print(b);
  66.                 System.out.println("******************");

  68.                 Dog d=(Dog)a;//向下转型
  69.                 d.say();
  70.                 System.out.println("******************");

  72.                 Cat c=(Cat)b;//向下转型
  73.                 c.say();
  74.         }
  75. }
复制代码
作者: 付江涛    时间: 2014-6-9 21:45
uu993 发表于 2014-6-9 21:32
嗯，是强制转化

多态虽然提高了扩展性，但是只能使用访问父类中的成员。所以要访问子类的方法，必须强制转换，向下转型。

第二种里就是将a向下转换成子类Dog对象并赋值给d，d只是个引用。
作者: 西门吹风    时间: 2014-6-9 22:27
当用父类引用指向子类实例对象时，父类引用只能访问子类中从父类继承过来的方法，包括被覆写的，相当于此时的这个父类引用虽然指向子类对象，但只具有父类的功能而没有子类特有的功能。这里a是父类引用变量，所以不能访问Dog类的特有方法，Dog d=(Dog)a，创建了一个子类引用对象，还是指向刚才的那Dog类实例，但由于是本类引用指向本类实例，可以访问本类中的所有非私有成员。
作者: Be_myself    时间: 2014-6-9 22:56
我觉得第一种是多态的体现，但多态的前提是    子类的方法存在重写，不知道你的程序这个能不能满足。如果可以那么， 第一种：Animal a=new Dog()   第一种是多态的体现。Animal的引用指向了自己的子类Dog对象. a  拥有了Animal的属性特征，实现多态。     第二种  Dog d=(Dog)a。   第二种     是向下转型，目的，为了调用子类非继承父类、自己特有的方法。因为多态有个弊端，只能使用父类的引用访问父类的成员。所以向下转型是为了访问子类自己的成员。首先，Dog 引用指向的实例对象本来就是子类类型的。所以赋值给子类类型引用变量非常可以。
然后现在用子类类型的引用就可以访问自己的成员方法了。
作者: Be_myself    时间: 2014-6-9 23:07
我觉得只是继承关系的话  d 中的方法是  睡觉， 叫， 摇尾巴。
作者: sam9204    时间: 2014-6-9 23:11
对于这个问题我也还有点疑惑，学习学习
作者: Solomon    时间: 2014-6-10 08:43
楼主看下多态吧！！！
作者: peku    时间: 2014-6-10 09:40
第一个是父类引用指向子类对象，不能调用父类中没有的方法，，并且方法中的执行内容以参考子类，因为可能存在覆盖。第二个是将父类引用强制转换为子类了，所以相当于 Dog d=原来的Dog对象，所以可以使用子类特有方法
作者: 友来友网    时间: 2014-6-10 10:52
这就是典型的多态



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