C++和java多态的区别

标签：java   c++   多态性   

多态在 Java 和 C++ 中的实现异同：

• 单继承情况下，两者实现在本质上相同，都是使用方法表，通过方法表的偏移量来调用具体的方法。

• Java 的方法表中包含 Java 类所定义的所有实例方法，而 C++ 的方法表则只包含需要动态绑定的方法 (virtual 修饰的方法 )。这样，在 Java 下所有的实例方法都要通过方法表调用，而 C++ 中的非虚方法则是静态绑定的。

• 任意 Java 对象只 “指向”一个方法表，而 C++ 在多重继承下则可能指向多个方法表，编译器保证这多个方法表的正确初始化。

• 多层继承中 C++ 面临的主要问题是 this 指针的调整，设计更精巧更复杂；而 Java 在接口调用时完全采用搜索的方式，实现更直观，但调用效率比实例方法调用要慢许多。

可以看到，两者之间既有相似之处，也有不同的地方。对于单继承的实现本质上是一样的，但也有细微的差别（如方法表）；差别最大的是对于多重继承（多重接口）的支持。实际上，由于 C++ 是静态编译型语言，它无法像 Java 那样，在运行时刻动态的“查找”所要调用的方法。

实例：

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

如果父类func是virtual的，则

Super *p =new Sub();

p->func(); // 调用子类的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，不会调用子类的。

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

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

ok,让我们进入正题。

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

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

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

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

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

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

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;

}

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，这是与Java的不同），所以这里调用的是Base::init()。

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

3. delete pb; 无关紧要。

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++中的好。还是以例子说明吧：

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;
}

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）没有被初始化，派生类根本不能重用基类的初始化函数。试问，如果初始化要在构造时完成，并且初始化逻辑比较复杂，派生类也需要额外的初始化，派生类是不是需要重新实现基类的初始化函数呢？这样的面向对象方法好不好呢？欢迎大家讨论。

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); 
          }   
     }

 (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类型

参考资料：

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

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

C++和java多态的区别

标签：java   c++   多态性   

原文地址：http://blog.csdn.net/yangquanhui1991/article/details/49668975