Java与C++继承中的重载，覆盖和隐藏

1.  Java中没有隐藏

在《谈谈C++继承中的重载，覆盖和隐藏》中，我给出了隐藏的定义。但是Java根本就没有这个隐藏的概念，基类中的函数，会继承下来，和继承类中的同名函数，一起成为继承类的重载函数。

请看例子：

class CB {

    public  void f(){

       System.out.println("CB::f()");    

    }

} 

class CD extends CB {

    public  void f(int a){

       System.out.println("CD::f(int)");

    }

}

public class MyTest {

    public static void main(String args[])
{

       System.out.println("helloWorld");

       CD test = new CD();

       test.f();

       test.f(1);

    }

}
运行结果就是：

helloWorld

CB::f()

CD::f(int)

而同样的代码，在C++中就完蛋了，

#include "stdafx.h"

#include "iostream"

using namespace std;

class CB {

public:

    void f(){

       cout<< "CB::f()" << endl;

    }

};

 

class CD : public CB {

public:

    void f(int a){

       cout<< "CD::f(int)" << endl;

    }

};

int _tmain(int argc, _TCHAR* argv[])

{

    CD test;

    test.f(1);

    test.f();

    return 0;

}

编译了一下

Error   1   error C2660: 'CD::f' : function does not take 0 arguments

在CD类中，根本就找不到这个f()，这个Java和C++就有区别了，感觉Java的比较合常理啊，我爸爸有辆大奔，我自己有辆宝马，我爸爸说，我的大奔就是你的大奔，那我当然既能开大奔，又能开宝马了，凭什么只能开宝马呢？啊，我的宝马在哪里？

2.  Java中的普通函数就能实现多态，不需virtual关键字

实例代码如下：

class CB {

    public  void f(){

       System.out.println("CB::f()");    

    }

}

class CD extends CB {

    public  void f(int a){

       System.out.println("CD::f(int)");

    }

    public  void f(){

       System.out.println("CD::f()");

    }

}

public class MyTest {

    public static void main(String args[])

    {

       System.out.println("helloWorld");

       CD cd = new CD();

       CB cb = new CB();

       CB cbd = new CD();

       cd.f();

       cb.f();

       cbd.f();

    }

}

运行结果：

helloWorld

CD::f()

CB::f()

CD::f()

而同样的代码，在C++中，运行的结果就会是：

CD::f()

CB::f()

CB::f()

如果在C++ 中f()定义成virtual函数，那么结果就和Java中一样了

CD::f()

CB::f()

CD::f()

换句话说，Java中的普通函数就能实现多态，而C++中，只有虚函数才能实现多态，书是这么写的"In Java, you do not need to declare a method as virtual. Dynamic binding is the default behavior. If you do not want a method to be virtual, you tag it as final" 《core java2 :volum I》，讲的很清楚了。

如果我把CＢ中的函数定义成final，就没办法在派生类重写（或者说覆盖？因为英语中用的是override）它了，如下：

class CB {

    final public  void f(){

       System.out.println("CB::f()");    

    }

那么编译错就是：Cannot override the final method from CB

在《谈谈C++继承中的重载，覆盖和隐藏》中，我讲到，C++中要实现这种多态的覆盖，要满足两个条件：

(a)有virtual关键字，在基类中函数声明的时候加上就可以了

(b)基类CB中的函数和派生类CD中的函数要一模一样，什么叫一模一样，函数名，参数，返回类型三个条件。

但是Java中，只要满足条件B就可以了，当然，返回参数还是要一样，否则编译错。

我们知道，如果在C++中，如果派生类重写了这个相同的函数f，如果这个f不是虚函数，那么如果我们用基类的指针指向一个派生类的对象，去调用这个函数f,那么调用的是CB::f()，只有f是个虚函数，才会调用CD::f()。那么Java中，如果一个基类的references，如这里的cbd，指向一个派生类的对象，如何才能调用CB::f()呢？

3.  Private不支持多态

实例如下吧：

class CB {

     private  void f(){

       System.out.println("CB::f()");    

    }

    public  void ff(){

       f();

    }

}

class CD extends CB {

    public  void f(){

       System.out.println("CD::f()");

    }

}

public class MyTest {

    public static void main(String args[])

    {

       System.out.println("helloWorld");

       CD cd = new CD();

       CB cb = new CB();

       CB cbd = new CD();

       cd.ff();

       cb.ff();

       cbd.ff();

    }

}

运行结果：

helloWorld

CB::f()

CB::f()

CB::f()

不光不支持多态，竟然cd.ff();的运行结果都是调用的基类的那个f函数

而我一旦把CB::f定义成public的，多态就又回来了结果如下：

helloWorld

CD::f()

CB::f()

CD::f()

这个结果对于我来说，比较惊讶，private函数不会被override!!同样的代码，在C++中，只要这个f是个虚函数，我管你private还是public还是protected，都会“多态的风生水起”：

#include "stdafx.h"

#include "iostream"

using namespace std;

class CB {

private:

     virtual void f(){

       cout<< "CB::f()" << endl;

    }

public:

    void ff(){

       f();

    }

};

 

class CD : public CB {

private:

    void f(){

       cout<< "CD::f()" << endl;

    }

};

 

int _tmain(int argc, _TCHAR* argv[])

{

    CD test;

    CB test2;

    CB * cb  = &test2;

    CD * cd = &test;

    CB * cbd = &test;

    cb->ff();

    cd->ff();

    cbd->ff();

    return 0;

}

运行结果：

CB::f()

CD::f()

CD::f()

嗯，到这里，可以说差不多可以写完了吧？基本上，把Java中的覆盖，重载和隐藏总结了一下，更重要的是，和C++进行了比较。总结一下就是，Java不会隐藏，会把基类的函数继承下来和继承类的形成多个重载函数，Java不需要Virtual就能实现多态，Java中的普通函数就==C++中的虚函数，如果不想覆盖，那么把函数定义成private的就可以了。