C++/Java中继承关系引发的调用关系详解

C++:

这里引用到了 http://blog.csdn.net/haoel/article/details/1948051/ 中的内容，还请提前阅读陈大神的这篇博客后在阅读本篇。

覆盖，实现多态的基础，通过虚函数表来实现，下面这个例子便是覆盖 Override

 #include<iostream>

 using namespace std;

 class Base{
 public:
     Base(){
         cout << "Base::Base" << endl;
     }

     virtual void f(){
         cout << "Base::f" << endl;
     }
 };

 class Derived : public Base{
 public:
     Derived(){
         cout << "Devried::Derived" << endl;
     }

     void f(){
         cout << "Derived::f" << endl;
     }
 };

 int main(){
     Base *p = new Derived(); // Base::Base CRCL Derived::Derived
     p->f(); // Derived::f
 }

如果 Base类f()没有被virtual修饰，如下

 #include<iostream>

 using namespace std;

 class Base{
 public:
     Base(){
         cout << "Base::Base" << endl;
     }

     void f(){
         cout << "Base::f" << endl;
     }
 };

 class Derived : public Base{
 public:
     Derived(){
         cout << "Devried::Derived" << endl;
     }

     void f(){
         cout << "Derived::f" << endl;
     }
 };

 int main(){
     Base *p = new Derived();
     p->f(); // Base::f
 }

如果理解了陈大神博客上那些图，应该不会对这个结果产生意外，这是我画的一个草图，并不对应于真实的内存地址情况，只是为了方便说明概念，下面一排描述的是Derived：

解析：首先p是Base类型的指针，其对于p而言其能只能按照Base类型去运算偏移地址等来访问，所以其不可能访问到Derived中的函数。也就是说父类指针的作用域只有int a ， Base::f Base::g这一部分。这样就能理解了。

隐藏，父类指针的访问域是父类部分，子类虽然拥有一份父类函数的拷贝，但如果子类中存在于父类同名的函数，则调用和变量类型一致的函数（即父类变量调用父类函数，子类变量调用子类函数，同时成对方的函数被隐藏）。例：

 #include<iostream>

 using namespace std;

 class Base{

 public:
     int a;

     Base(){
         cout << "Base::Base" << endl;
     }

     void f(float a){
         cout << "Base::f" << endl;
     }
 };

 class Derived : public Base{
 public:
     int d;
     Derived(){
         cout << "Devried::Derived" << endl;
     }

     void f(int a){
         cout << "Derived::f" << endl;
     }
 };

 int main(){
     Derived *p = new Derived();
     p->f(3.14f); // Derived::f
 }

这里虽然传入f的参数是float型，更适合调用Base::f，但根据同名优先调用子类的原则，实际调用为Derived::f。这就是父类同名方法被隐藏，如果指针类型为父类，则称子类方法被隐藏。

如果子类f定义为 void f() 这里对f传值就会编译不通过。

Java

覆盖，java的情况很简单，只要是子类含有和父类的同名方法，就是覆盖（无论子类的函数是否为abstract）。

public class Test {
    public static void main(String[] args){
        Base base = new Derived();
        base.f(); // Derived::f
    }
}

class Base {

    public void f() {
        System.out.println("Base::f");
    }
}

class Derived extends Base {
    public void f() {
        System.out.println("Derived::f");
    }
}

隐藏，Java中也存在隐藏，不过这个隐藏和C++不太一样，子类对象引用可以调用父类的同名函数

 public class Test {
     public static void main(String[] args){
         Derived derived = new Derived();
         derived.f(); //Derived::f
         derived.f(3.14f); // Base::f
     }
 }

 class Base {

     public void f(float a) {
         System.out.println("Base::f");
     }
 }

 class Derived extends Base {
     public void f(int a) {
         System.out.println("Derived::f");
     }
 }

再讲覆盖，C++父类函数中如果调用了自己的虚成员函数，那么由于这个虚成员函数被覆盖了，所以其实相当于调用了子类的函数。例：

#include<iostream>

using namespace std;

class Base{

public:
    int a;

    Base(){
        cout << "Base::Base" << endl;
    }

    void f(){
        g();
    }

    virtual void g(){
        cout << "Base::g" << endl;
    }
};

class Derived : public Base{
public:
    int d;
    Derived(){
        cout << "Devried::Derived" << endl;
    }

    void g(){
        cout << "Derived::g" << endl;
    }
};

int main(){
    Derived *p = new Derived();
    p->f(); // Derived::g
}

Java中类似：

 public class Test {
     public static void main(String[] args){
         Base base = new Derived();
         base.f(); //Derived::f
     }
 }

 class Base {

     public void f() {
         g();
     }

     public void g(){
         System.out.println("Base::g");
     }
 }

 class Derived extends Base {
     public void g(){
         System.out.println("Derived::g");
     }
 }

由于想利用这种特性，有人会犯一个错误，在父类的构造函数中调用被覆盖的函数，由于子类在构建时先调用父类的构造函数，此时子类为构造所以不能调到子类的覆盖方法，由此

产生了奇怪的错误。