首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >C++和java多态的区别

C++和java多态的区别

作者头像
bear_fish
发布2018-09-20 11:26:16
8770
发布2018-09-20 11:26:16
举报

http://blog.csdn.net/yangquanhui1991/article/details/49668975

C++和java中多态机制的异同

以前我有个错误的观点:即使在C++和java中多态性的实现机制可能不同,但它们的表现形式应该相同,也就是说如果代码结构相同,那么执行结果也应该相同。可惜事与愿违,事情并不总是你想象中的那样子。(在看下文以前,你最好先考虑一下这个问题,你有什么看法呢?)

ok,让我们进入正题。

首先本文不讨论面向对象编程的基本概念,如封装、继承和数据抽象等,这方面的资料现在应该多如牛毛,只是稍微提一下多态性的概念。根据Bjarne Stoustrup的说法,多态性其实就是方法调用的机制,也就是说当在编译时无法确定一个对象的实际类型时,应当能够在运行时基于对象的实际类型来决定调用的具体方法(动态绑定)。

我们先来看一下在C++中的函数调用方式:

Ø 普通函数调用:具体调用哪个方法在编译时间就可以决定(通过查找编译器的符号表),同时在使用标准过程调用机制基础上增加一个表示对象身份的指针(this指针)。

Ø 虚函数调用:函数调用依赖于对象的实际类型,一般地说,对象的实际类型只能在运行时间才能确定。虚函数一般要有两个步骤来支持,首先每一个类产生出一堆指向虚函数的指针,放在表格中,这个表格就叫虚函数表(virtual table);然后每一个类对象(class object)会添加一个指向相关虚函数表(virtual table)的指针,通常这个指针叫做vptr。

在Java中的函数调用方式: 区别还是满大的。在java虚拟机中,类实例的引用就是指向一个句柄(handle)的指针,而该句柄(handle)其实是一对指针:其中一个指针指向一张表,该表格包含了对象的方法列表以及一个指向类对象(表示对象类型)的指针;另一个指针指向一块内存地址,该内存是从java堆中为对象的数据而分配出来的。

唔,你要说了,好象差不多嘛,不是都要维护一张函数表吗?别急,让我们先看一下例子,这样你就能更好的理解它们之间的区别到底有多大了。

下面是C++和java的例子,不看后面的答案,你能够正确说出它们的执行结果吗?

例1:C++

[cpp] view plaincopy

  1. class Base  
  2. {  
  3. public:  
  4.         Base(){init();}  
  5. virtual ~Base() {}  
  6. public:  
  7. virtual void do_init(){init();}  
  8. protected:  
  9. virtual void init()  
  10.         {  
  11.            cout << "in Base::init()" << endl;  
  12.         }  
  13. };  
  14. class Derived : public Base  
  15. {  
  16. public:  
  17.         Derived(){init();}  
  18. protected:  
  19. void init()  
  20.         {  
  21.             cout << "in Derived::init()" << endl;  
  22.         }  
  23. };  
  24. int main(int argc, char* argv[])  
  25. {  
  26.     Base* pb;  
  27.     pb = new Derived();  
  28. delete pb;  
  29. return 0;  
  30. }  

例2:java

[java] view plaincopy

  1. class Base  
  2. {  
  3. public Base(){init();}  
  4. protected void init()  
  5.     {  
  6.         System.out.println("in Base::init()");  
  7.     }  
  8. public void do_init() {init();}  
  9. }  
  10. class Derived extends Base  
  11. {  
  12. public Derived(){init();}  
  13. protected void init()  
  14.     {  
  15.         System.out.println("in Derived::init()");  
  16.     }  
  17. }  
  18. public class Test  
  19. {  
  20. public static void main(String[] args)  
  21.     {  
  22.         Base base = new Derived();  
  23.     }  
  24. }  

例1的执行结果是:

in Base::init()

in Derived::init()

例2的执行结果是:

in Derived::init()

in Derived::init()

看了结果后,你是马上顿悟呢抑或是处于疑惑中呢?ok,我们来分析一下两个例子的执行过程。

首先看一下例1(C++的例子):

[cpp] view plaincopy

  1. 1. Base* pb; 只是声明,不做什么。  
  2. 2. pb = new Derived();  

1) 调用new操作符,分配内存。

2) 调用基类(本例中是Base)的构造函数

3) 在基类的构造函数中调用init(),执行程序首先判断出当前对象的实际类型是Base(注意:Derived还没构造出来,当然不会是Derived,这是与Java的不同),所以这里调用的是Base::init()。

4) 调用派生类(本例中是Derived)的构造函数,在这里同样要调用init(),执行程序判断出当前对象的实际类型是Derived,调用Derived::init()。

[cpp] view plaincopy

  1. 3. delete pb; 无关紧要。  

例2(java的例子)的执行过程:

[java] view plaincopy

  1. 1. Base base = new Derived();  

1) 分配内存。

2) 调用基类(本例中是Base)的构造函数

3) 在基类的构造函数中调用init(),执行程序首先判断出当前对象的实际类型是Derived(注意:Derived已经构造出来,它的函数表当然也已经确定了,这是与C++的不同)所以这里调用的是Derived::init()。

4) 调用派生类(本例中是Derived)的构造函数,在这里同样要调用init(),执行程序判断出当前对象的实际类型是Derived,调用Derived::init()。

明白了吧。java中的类对象在构造前(调用构造函数之前)就已经存在了,其函数表和对象类型也已经确定了,就是说还没有出生就已经存在了。而C++中只有在构造完毕后(所有的构造函数都被成功调用)才存在,其函数表和对象的实际类型才会确定。所以这两个例子的执行结果会不一样。当然,构造完毕后,C++与java的表现就都一样了,例如你调用Derived::do_init()的话,其执行结果是:

in Derived::init()。

个人认为,java中的多态实现机制没有C++中的好。还是以例子说明吧:

例子3:C++

[cpp] view plaincopy

  1. class Base  
  2. {  
  3. public:  
  4.         Base(){init();}  
  5. virtual ~Base() {}  
  6. protected:  
  7. int value;  
  8. virtual void init()  
  9.         {  
  10.             value = 100;  
  11.         }  
  12. };  
  13. class Derived : public Base  
  14. {  
  15. public:  
  16.         Derived(){init();}  
  17. protected:  
  18. void init()  
  19.         {  
  20.             cout << "value = " << value << endl;  
  21. // 做一些额外的初始化工作
  22.         }  
  23. };  
  24. int main(int argc, char* argv[])  
  25. {  
  26.     Base* pb;  
  27.     pb = new Derived();  
  28. delete pb;  
  29. return 0;  
  30. }  

例4:java

[java] view plaincopy

  1. class Base  
  2. {  
  3. public Base(){init();}  
  4. protected int value;  
  5. protected void init(){value = 100;}  
  6. }  
  7. class Derived extends Base  
  8. {  
  9. public Derived(){init();}  
  10. protected void init()  
  11.     {  
  12.          System.out.println("value = " + value);  
  13. // 做一些额外的初始化工作
  14.      }  
  15. }  
  16. public class Test  
  17. {  
  18. public static void main(String[] args)  
  19.      {  
  20.        Base base = new Derived();  
  21.       }  
  22. }  

例3的执行结果是:

value = 10

例4的执行结果是:

value = 0

value = 0

从以上结果可以看出,java例子中应该被初始化的值(这里是value)没有被初始化,派生类根本不能重用基类的初始化函数。试问,如果初始化要在构造时完成,并且初始化逻辑比较复杂,派生类也需要额外的初始化,派生类是不是需要重新实现基类的初始化函数呢?这样的面向对象方法好不好呢?欢迎大家讨论。

例5:java

[java] view plaincopy

  1. class Parent{  
  2. int x=10;   
  3. public Parent(){   
  4.                add(2);   
  5.           }   
  6. void add(int y){   
  7.                x+=y;   
  8.           }   
  9.      }  
  10. class Child extends Parent{   
  11. int x=9;   
  12. void add(int y){   
  13.                x+=y;   
  14.           }   
  15. public static void main(String[] args){   
  16.                Parent p=new Child();   
  17.                System.out.println(p.x);   
  18.           }     
  19.      }  

问输出结果是什么?       答案应该是10。       要理解结果为什么是10,需要首先明白下面的知识: 

 (1)方法和变量在继承时的隐藏与覆盖 

隐藏:若B隐藏了A的变量或方法,那么B不能访问A被隐藏的变量或方法,但将B转换成A后可以访问A被隐藏的变量或者方法。 

   覆盖:若B覆盖了A的变量或者方法,那么不仅B不能访问A被覆盖的变量或者方法,将B转换成A后同样不能访问A被覆盖的变量或者方法。 

(2)Java中变量与方法在继承中的隐藏与覆盖规则: 

          一、父类的实例变量和类变量能被子类的同名变量隐藏。            二、父类的静态方法被子类的同名静态方法隐藏,父类的实例方法被子类的同名实例方法覆盖。            三、不能用子类的静态方法隐藏父类的实例方法,也不能用子类的实例方法覆盖父类的静态方法,否则编译器会异常。            四、用final关键字修饰的最终方法不能被覆盖。            五、变量只能被隐藏不会被覆盖,子类的实例变量可以隐藏父类的类变量,子类的类变量也可以隐藏父类的实例变量。 

     在上面的试题中,子类Child的实例方法add(int y)覆盖了父类Parent的实例方法add(int y),而子类的实例变量x则是隐藏了父类的实例变量x。 

     Child对象的初始化过程是: 

     首先为父类的实例变量x分配内存空间,因为在定义变量x时为它赋了值(int x=10),所以会同时将这个值赋给x。       其次调用父类的无参构造函数,Parent的构造函数中做的唯一的事情就是调用了add(2);       第三、由于子类的add(int y)方法覆盖了父类的方法,所以add(2)实际调用的是子类的方法,在子类的add方法中做了如下操作x+=j;在这里由于子类的实例变量x隐藏了父类的实例变量x,所以这条语句是针对子类本身的,但是这时还没有为子类的实力变量x分配空间,它的默认值是0,加2之后是2。       第四、父类初始化完毕后接着初始化子类,为子类的x分配内存空间并将它赋值为9,之前的add(2)操作白瞎了。       再次注意Parent p=new Child();这条语句,它是用父类的引用指向子类的对象,而前面已经说过变量只会被隐藏不会被覆盖,所以这时的p.x值应该是父类的10,而不是子类的9; 

     如果将输出语句换成下面的语句结果就是9了: 

[java] view plaincopy

  1. System.out..println(((Child)p).x); //首先将p转换成Child类型

参考资料:

http://blog.csdn.net/pi9nc/article/details/12057863

http://developer.51cto.com/art/201104/253549.htm

版权声明:转载需标明博客来源:http://blog.csdn.net/yangquanhui1991 大家互相学习,一起进步!

本文参与 腾讯云自媒体分享计划,分享自作者个人站点/博客。
原始发表:2015年11月06日,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档