zoukankan      html  css  js  c++  java
  • C++和java多态的区别

    C++和java多态的区别

    分类: Java 2人阅读 评论(0) 收藏 举报
    

    转载自:http://www.cnblogs.com/plmnko/archive/2010/10/19/1855760.html

    C++中,如果父类中的函数前边标有virtual,才显现出多态。

    如果父类func是virtual的,则

    Super *p =new Sub();

    p->func(); // 调用子类的func

    如果不是virtual的,p->func将调用父类原来的函数。

    Java中,不管写不写virtual都是多态的,子类的同名函数会override父类的。与C++很不同的是,初始化的过程也不相同。在还未初始化子类的时候,子类的同名函数就已经覆盖了父类的了。例如:

    public class Super { 
        public Super() { 
            System.out.println("super constructor..."); 
            m(); 
        }

        protected void m() {

            System.out.println("test"); 
        } 
    }

    public class Sub extends Super{ 
        private final Date date; 
        public Sub(){

                System.out.println("sub constructor...");         
            date=new Date();} 
        public void m() 
        { 
            System.out.println(date); 
        }

        public static void main(String[] args) 
        {  
            Super test1=new Sub();

            test1.m();  //执行的子类的m 
        } 
    }

    new Sub的时候首先调用Super,Super构造函数调用的m就已经是被Sub覆盖的m,所以会print出null(因为日期没有初始化)。所以在java中,不要在父类构造函数中调用外部可改变的方法,有可能会输出可改变方法中还没初始化的东西。

    但是,同样的初始化在C++中,初始化一个子类的时候,父类调用的m,是父类自己的m,不会调用子类的。

    ——————

    另外一个参考也很有用:http://7880.com/info/Article-51701560.html,如下:

    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++

    class Base

    {

    public:

    Base()

    {

    init();

    }

    virtual ~Base() {}

    public:

    virtual void do_init()

    {

    init();

    }

    protected:

    virtual void init()

    {

    cout << "in Base::init()" << endl;

    }

    };

    class Derived : public Base

    {

    public:

    Derived()

    {

    init();

    }

    protected:

    void init()

    {

    cout << "in Derived::init()" << endl;

    }

    };

    int main(int argc, char* argv[])

    {

    Base* pb;

    pb = new Derived();

    delete pb;

    return 0;

    }

    例2:java

    class Base

    {

    public Base()

    {

    init();

    }

    protected void init()

    {

    System.out.println("in Base::init()");

    }

    public void do_init()

    {

    init();

    }

    }

    class Derived extends Base

    {

    public Derived()

    {

    init();

    }

    protected void init()

    {

    System.out.println("in Derived::init()");

    }

    }

    public class Test

    {

    public static void main(String[] args)

    {

    Base base = new Derived();

    }

    }

    例1的执行结果是:

    in Base::init()

    in Derived::init()

    例2的执行结果是:

    in Derived::init()

    in Derived::init()

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

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

    1. Base* pb; 只是声明,不做什么。

    2. pb = new Derived();

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

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

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

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

    3. delete pb; 无关紧要。

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

    1. Base base = new Derived();

    1) 分配内存。

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

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

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

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

    in Derived::init()。

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

    例子3:C++

    class Base

    {

    public:

    Base()

    {

    init();

    }

    virtual ~Base() {}

    protected:

    int value;

    virtual void init()

    {

    value = 100;

    }

    };

    class Derived : public Base

    {

    public:

    Derived()

    {

    init();

    }

    protected:

    void init()

    {

    cout << "value = " << value << endl;

    // 做一些额外的初始化工作

    }

    };

    int main(int argc, char* argv[])

    {

    Base* pb;

    pb = new Derived();

    delete pb;

    return 0;

    }

    例4:java

    class Base

    {

    public Base()

    {

    init();

    }

    protected int value;

    protected void init()

    {

    value = 100;

    }

    }

    class Derived extends Base

    {

    public Derived()

    {

    init();

    }

    protected void init()

    {

    System.out.println("value = " + value);

    // 做一些额外的初始化工作

    }

    }

    public class Test

    {

    public static void main(String[] args)

    {

    Base base = new Derived();

    }

    }

    例3的执行结果是:

    value = 10

    例4的执行结果是:

    value = 0

    value = 0

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

    作者的联系方式:smart_ttc@yahoo.com.cn

    Reference:

    1. Stanley B. Lippman:深度探索C++对象模型(Inside The C++ Object Model)。

    ---- 侯捷译,华中科技出版社 2001

    ——————

    另外一个关于java的例子:

    http://blog.csdn.net/lzz313/archive/2009/06/16/4274936.aspx

    class Parent{

              int x=10; 
              public Parent(){ 
                   add(2); 
              } 
              void add(int y){ 
                   x+=y; 
              } 
         }

         class Child extends Parent{ 
              int x=9; 
              void add(int y){ 
                   x+=y; 
              } 
              public static void main(String[] args){ 
                   Parent p=new Child(); 
                   System.out.println(p.x); 
              }   
         }

      问输出结果是什么? 
         答案应该是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了: 
         System.out..println(((Child)p).x); //首先将p转换成Child类型


  • 相关阅读:
    初认识AngularJS
    (imcomplete) UVa 10127 Ones
    UVa 10061 How many zero's and how many digits?
    UVa 11728 Alternate Task
    UVa 11490 Just Another Problem
    UVa 10673 Play with Floor and Ceil
    JSON对象和字符串的收发(JS客户端用typeof()进行判断非常重要)
    HTML.ActionLink 和 Url.Action 的区别
    EASYUI TREE得到当前节点数据的GETDATA方法
    jqueery easyui tree把已选中的节点数据拼成json或者数组(非常重要)
  • 原文地址:https://www.cnblogs.com/likeFlyingFish/p/5346017.html
Copyright © 2011-2022 走看看