学完继承之后，看到两种继承的表达形式，但是自己没有看明白，不知道这两种方式有什么区别；
第一种：Animal a=new Dog()；第二种： Dog d=(Dog)a。


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

那么第二种，d中的方法是什么呢

睡觉，叫，摇尾巴

SyouRai_Tsk 发表于 2014-6-9 20:52
睡觉，叫，摇尾巴

可以详细一点吗~

强制转换吧

你这个问题是多态,多态的前提之一是重写,你的方法不存在重写啊

付江涛 发表于 2014-6-9 21:02
强制转换吧

嗯，是强制转化

多态
对象在不同时刻表现出来的不同状态（对于引用类型，有两个状态：编译期状态、运行期状态）
实现多态的前提：需要存在继承或者实现关系；需要有方法重写；由父类引用指向子类对象
格式：父类 变量名=new 子类（）；

1. class Animal
   
2. {
   
3.         public Animal(){}
   
4. 
   
5.         public void show()
   
6.         {
   
7.                 System.out.println("Animal show");
   
8.         }
   
9. 
   
10.         public void eat()
    
11.         {
    
12.                 System.out.println("Animal eat");
    
13.         }
    
14. }
    
15. 
    
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.         }
    
26. 
    
27.         public void say()
    
28.         {
    
29.                 System.out.println("I'm Dog");
    
30.         }
    
31. 
    
32. }
    
33. 
    
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.         }
    
48. 
    
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("******************");
    
67. 
    
68.                 Dog d=(Dog)a;//向下转型
    
69.                 d.say();
    
70.                 System.out.println("******************");
    
71. 
    
72.                 Cat c=(Cat)b;//向下转型
    
73.                 c.say();
    
74.         }
    
75. }
    

复制代码

uu993 发表于 2014-6-9 21:32
嗯，是强制转化

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

第二种里就是将a向下转换成子类Dog对象并赋值给d，d只是个引用。

当用父类引用指向子类实例对象时，父类引用只能访问子类中从父类继承过来的方法，包括被覆写的，相当于此时的这个父类引用虽然指向子类对象，但只具有父类的功能而没有子类特有的功能。这里a是父类引用变量，所以不能访问Dog类的特有方法，Dog d=(Dog)a，创建了一个子类引用对象，还是指向刚才的那Dog类实例，但由于是本类引用指向本类实例，可以访问本类中的所有非私有成员。

我觉得第一种是多态的体现，但多态的前提是    子类的方法存在重写，不知道你的程序这个能不能满足。如果可以那么， 第一种：Animal a=new Dog()   第一种是多态的体现。Animal的引用指向了自己的子类Dog对象. a  拥有了Animal的属性特征，实现多态。     第二种  Dog d=(Dog)a。   第二种     是向下转型，目的，为了调用子类非继承父类、自己特有的方法。因为多态有个弊端，只能使用父类的引用访问父类的成员。所以向下转型是为了访问子类自己的成员。首先，Dog 引用指向的实例对象本来就是子类类型的。所以赋值给子类类型引用变量非常可以。
然后现在用子类类型的引用就可以访问自己的成员方法了。

我觉得只是继承关系的话  d 中的方法是  睡觉， 叫， 摇尾巴。

对于这个问题我也还有点疑惑，学习学习

楼主看下多态吧！！！

第一个是父类引用指向子类对象，不能调用父类中没有的方法，，并且方法中的执行内容以参考子类，因为可能存在覆盖。第二个是将父类引用强制转换为子类了，所以相当于 Dog d=原来的Dog对象，所以可以使用子类特有方法

这就是典型的多态