Java静态多态性和动态多态性有何区别？分别又是如何体现的呢？

静态多态性指的是程序在编译时，系统就能决定调用哪个函数，如重载。
动态多态性指在运行中才能动态确定操作指针所指的对象，主要通过虚函数和重写来实现。
java 的多态机制遵循一个原则：当父类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法 .
简单来说，静态多态性就是指方法的重载，是在一个类中的行为。
动态多态性是指方法的重写，即多态，是在有继承关系的两个或两个以上的类中的行为。概念理解起来有点抽象。还是看个例子吧。

1. //静态多态性：
   
2. add(int a);
   
3. add(int a,int b);
   
4. add(double a);
   
5. add(double a,double b);
   
6. 
   
7. //动态多态性
   
8. public class A{ }
   
9. 
   
10. public class AB extends A{ }
    
11. 
    
12. public class AC extends A{ }
    
13. 
    
14. public class test{
    
15.   go(A a);
    
16. }

复制代码

柳 德 彬 发表于 2013-4-11 20:04
静态多态性指的是程序在编译时，系统就能决定调用哪个函数，如重载。
动态多态性指在运行中才能动态确定操 ...

java不是没有指针和虚函数吗？

简单来说，静态多态性就是指方法的重载，是在一个类中的行为。动态多态性是指方法的重写，即多态，是在有继承关系的两个或两个以上的类中的行为。

张旺达 发表于 2013-4-11 20:11
java不是没有指针和虚函数吗？

我只知道有指针 不过是体现形式不一样而已。

参见毕老师“多态中成员函数的特点”：

当父类引用指向子类对象时，
1，编译时期：参阅引用变量所属的类中是否有调用的方法，如果有，编译通过，如果没有，则编译失败。
2，运行时期：参阅对象所属的类中是否有调用的方法。

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。
这个比说动态静态好理解一些。更不用提什么虚函数和指针。

示例如下：

1. class Fu
   
2. {
   
3.         void method1()
   
4.         {
   
5.                 System.out.println("fu method_1");
   
6.         }
   
7.         void method2()
   
8.         {
   
9.                 System.out.println("fu method_2");
   
10.         }
    
11. }
    
12. 
    
13. class Zi extends Fu
    
14. {
    
15.         void method1()
    
16.         {
    
17.                 System.out.println("zi method_1");
    
18.         }
    
19.         void method3()
    
20.         {
    
21.                 System.out.println("zi method_3");
    
22.         }
    
23. }
    
24. 
    
25. class DuoTaiDemo
    
26. {
    
27.         public static void main(String[] args)
    
28.         {
    
29.                 Fu f = new Zi();
    
30. 
    
31.                 f.method1();//可以运行，因为编译时期，父类有method1方法。
    
32.                 f.method2();//可以运行，因为编译时期，父类有method2方法。
    
33. 
    
34.                 //f.method3();不可以运行，因为编译时期，父类没有method3方法。
    
35.         }
    
36. }

复制代码

程序的运行结果是：

zi method_1
fu method_2

因为运行时是参阅子类的方法，有method1方法，所以运行子类的method_1；没有method2方法，所以运行子类的method_2。

最后一句纠正一下，“没有method2方法，运行父类的method_2。”

多态自始至终都是子类对象在做着变化。类型提升以后，对象就只有父类当中的内容，而没有子类本身所特有（即子类有而父类没有）的功能了，必须要把它强制转成子类类型才具有它所特有的功能。但是父类当中的内容会被子类当中的覆盖（即功能自始至终都是子类的）。
也就是说：
多态的出现代码中的特点（多态的使用注意情况）
        在编译时期：参阅引用型变量所属的类中（即父类）是否有调用的方法。如果有，编译通过，如果没有，编译失败。
        在运行时期：参阅对象所属的类中是否有调用的方法。
        简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。比如：Animal a=new Cat();表示父类引用指向子类对象。
在多态中，成员变量的特点：
        无论编译和运行，都参考左边（引用型变量所属的类）
        在多态中，静态成员函数的特点：
        无论编译和运行，都参考左边
静态就是指编译时期，动态就是指运行时期。
好好思考这些话，再结合上面的程序，就能理解了，不难。

张旺达 发表于 2013-4-11 20:11
java不是没有指针和虚函数吗？

就是方法。。。

静态多态性指的是程序在编译时，系统就能决定调用哪个函数，如重载。 动态多态性指在运行中才能动态确定操作指针所指的对象，主要通过虚函数和重写来实现。 java 的多态机制遵循一个原则：当父类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法

如果问题未解决，请继续追问，如果没有问题了，请将帖子分类 改为“已解决”，谢谢