只知道Java有多态这个概念。不知道具体这个是用在什么方面。父类引用指向子类对象又有什么好处。希望能举例说清楚。谢谢。

多态：可以理解为事物存在的多种体现形态。

                人：男人，女人

                动物：猫，狗。

                猫 x = new 猫();

                动物 x = new 猫();

                1，多态的体现
                        父类的引用指向了自己的子类对象。
                        父类的引用也可以接收自己的子类对象。
                2，多态的前提
                        必须是类与类之间有关系。要么继承，要么实现。
                        通常还有一个前提：存在覆盖。

                3，多态的好处
                        多态的出现大大的提高程序的扩展性。

                4，多态的弊端：
                        提高了扩展性，但是只能使用父类的引用访问父类中的成员。
                        虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员。               

        (1)同一个对象，在程序不同时刻的多种运行状态。举例：动物，狗是狗，狗是动物。水(气态，液态，固态)
        (2)多态前提
                A:存在着继承或者实现关系
                B:有方法的重写
                C:父类(接口)引用指向子类(实现)对象
        (3)多态的好处和弊端：
                好处：多态的存在提高了程序的扩展性和后期可维护性
                弊端：虽然可以预先使用，但是只能访问父类中已有的功能，运行的是后期子类的功能内容。不能预先使用子类中定义的特有功能。
        (4)多态中对象调用成员的特点
                Fu f = new Zi();
A:成员变量
                        编译看左边，运行看左边
                B:成员方法
                        编译看左边，运行看右边
                C:静态方法
                        编译看左边，运行看左边
        (5)多态的思想
                指挥同一批对象做事情。举例：带兵打仗，下课等。
       (6)使用的地方就多了去了，可以说无处不在，最常用的地方就是在接口开发模式与工厂开发模式等。

多态是面向对象程序设计的一个非常重要的特性，是指在程序中使用相同的名称来表示不同的含义。例如用一个方法名来表示不同的操作。
除了使用相同的名称来表示不同的方法以外，多态在面向对象程序设计中还拥有更广泛的应用，如“虚方法调用”，也称作方法调用绑定，可以使同样的访问代码适用于所有的之类，这样提高了程序的抽象程度，也使代码更为简洁。
定义了一个子类Cat，它继承了Animal类，那么后者就是前者是父类。我可以通过
　　Cat c = new Cat();
　　实例化一个Cat的对象，这个不难理解。但当我这样定义时：
　　Animal a = new Cat();
　　这代表什么意思呢？
　　很简单，它表示我定义了一个Animal类型的引用，指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal，所以Animal类型的引用是可以指向Cat类型的对象的。那么这样做有什么意义呢？因为子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特，
　　定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。
　　所以，父类类型的引用可以调用父类中定义的所有属性和方法，而对于子类中定义而父类中没有的方法，它是无可奈何的；
　　同时，父类中的一个方法只有在在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；
　　对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。
举例：

1. 　class Father{
   
2. 　　public void func1(){
   
3. 　　func2();
   
4. 　　}
   
5. 　　//这是父类中的func2()方法，因为下面的子类中重写了该方法
   
6. 　　//所以在父类类型的引用中调用时，这个方法将不再有效
   
7. 　　//取而代之的是将调用子类中重写的func2()方法
   
8. 　　public void func2(){
   
9. 　　System.out.println("AAA");
   
10. 　　}
    
11. 　　}
    
12. 　　class Child extends Father{
    
13. 　　//func1(int i)是对func1()方法的一个重载
    
14. 　　//由于在父类中没有定义这个方法，所以它不能被父类类型的引用调用
    
15. 　　//所以在下面的main方法中child.func1(68)是不对的
    
16. 　　public void func1(int i){
    
17. 　　System.out.println("BBB");
    
18. 　　}
    
19. 　　//func2()重写了父类Father中的func2()方法
    
20. 　　//如果父类类型的引用中调用了func2()方法，那么必然是子类中重写的这个方法
    
21. 　　public void func2(){
    
22. 　　System.out.println("CCC");
    
23. 　　}
    
24. 　　}
    
25. 　　public class PolymorphismTest {
    
26. 　　public static void main(String[] args) {
    
27. 　　Father child = new Child();
    
28. 　　child.func1();//打印结果将会是什么？
    
29. 　　}
    
30. 　　}

复制代码

上面的程序是个很典型的多态的例子。子类Child继承了父类Father，并重载了父类的func1()方法，重写了父类的func2()方法。重载后的func1(int i)和func1()不再是同一个方法，由于父类中没有func1(int i)，那么，父类类型的引用child就不能调用func1(int i)方法。而子类重写了func2()方法，那么父类类型的引用child在调用该方法时将会调用子类中重写的func2()。
　　那么该程序将会打印出什么样的结果呢？
　　很显然，应该是“CCC”。
　　对于多态，可以总结它为：
　　一、使用父类类型的引用指向子类的对象；
　　二、该引用只能调用父类中定义的方法和变量；
　　三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）
　　四、变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。

Sword 发表于 2013-5-17 17:01
多态是面向对象程序设计的一个非常重要的特性，是指在程序中使用相同的名称来表示不同的含义。例如用一个方 ...

谢谢了。

潘廖明 发表于 2013-5-17 16:38
(1)同一个对象，在程序不同时刻的多种运行状态。举例：动物，狗是狗，狗是动物。水(气态，液态，固 ...

恩。现在明白了一点儿了

逸盏清茶 发表于 2013-5-17 16:23
多态：可以理解为事物存在的多种体现形态。

                人：男人，女人

这些基本都知道的。嘿嘿

66666666666666666666666666666666