谈谈Java继承中的重载，覆盖和隐藏

谈谈Java继承中的重载，覆盖和隐藏

好久不写博客了，距离上一篇已经过了两年多了。这两年在干嘛,总之一年难尽！

前一段时间忙了两个月，忙着研究和做一些SSH架构的东西，两个月下来，收获颇丰，最近闲下来了，于是就痛快的开始玩游戏，但是不知怎么地，怎么玩都没意思，于是决定开始再好好研究研究Java吧。于是大概翻了翻《Thinking in Java》。

还是觉得把心得写下来比较好，一方面加深理解，另一方面，年纪大了，记性不好了，记不住关键的，“好记性不如烂笔头”，更何况我记性不好呢？写博客是为了自己学习使用，前几天看到自己博客里的文章在别的网站或者别人的博客转载还不写出处，于是心理不舒服，所以强调一下，转载请注明出处-即转载自handsomerun的CSDN博客。

好，切入正题，差不多4年前，写过一篇《谈谈C++继承中的重载，覆盖和隐藏》（http://blog.csdn.net/handsomerun/archive/2006/04/23/674210.aspx），同样目的也是为了加深自己的理解，我是一个很喜欢C/C++的人，学习Java的时候，就不由得和拿Java和C++进行比较，和写C++的那篇姐妹篇一样，还得先把定义翻译一下：重载(overload)，覆盖(override),隐藏(hide)。我看一本翻译过来的《Thinking in Java》的时候，看到他把override翻译成重载很是郁闷，所以，很多时候，结合英文版以及侯捷版一起看。

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

啊，到凌晨12点都过了，可以洗洗睡了。文章到这里就可以告一段落了，下来有空有心情的话，还会写一些总结的博客，用于自己学习总结。还是那句话，如要转载，请注明出处，谢谢合作。（hansomerun）