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的就可以了。