C++与JAVA多态相同与不同

C++与Java中继承与多态是十分重要的特性，但在学习中发现并没有一篇将这两者做比较与总结，所以写下自己观点，本文中有自己的原创，也有引用网上经典的分析与例子，引用部分会说明并贴出链接。不足之处希望大家指正。

首先说一下Java与C++继承的不相同特性，也是最容易让人混淆的三个概念：重载，重写，重定义
重载overload：重载是同名函数具有不同的形参列表（参数类型或数量），只有在同一个类内的函数才能叫做重载。
重写Overriding：重写是C++中的概念，子类与父类有同名函数，仅仅只需要函数名称相同，形参表可以不同，则子类会覆盖父类的函数。虽然很多人在Java中也提到了重写的概念，但实际上是重定义(很快会给出解释),因为在Java中子类会继承父类同名但参数不同的函数，作为重载，而在C++中父类的同名函数是不会继承的。下面分别给出C++和Java的例子。

C++

class A
{
public:
     void show(string s)
    {
        cout << s;
    }
};
class B:public A
{
public:
    void show(int i)
    {
        cout << i;
    }

};
int main()
{
    int i = 0;
    string s = "1";
    B b;
    b.show(i);
    b.show(s);

}

以上代码编译后出现error C2664: “void B::show(int)”: 无法将参数 1 从“std::string”转换为“int”
可以看出B并没有继承A的参数为string的show函数，与此类似，但是在Java中就不一样了

Java

public class A {
    public void show(String s)
    {
        System.out.println(s);
    }   
}   
public class B extends A{  
    public void show(int i)
    {
        System.out.println(i);
    }   
    static public void main(String[]args){
        int i=0;
        String s="1";
        B b=new B();
        b.show(i);
        b.show(s);

    }

}  

以上代码会输出0，1；可以看出Java会继承父类的同名但形参不同的函数

重定义redefining：重定义是重写的加强版本，必须要求子类中函数名以及形参和父类完全相同，在C++中，子类不会继承父类同名函数，所以重定义自然在子类中唯一；在Java中由于函数与父类完全相同，所以重定义会覆盖父类的同名同参函数（这也是为什么上面我说很多人把重定义当成了重写），重定义是实现多态的关键技术。

下面来说多态，多态的实现机制C++与Java几乎是相同的。首先解释一下什么叫做多态。
多态是指父类引用子类对象，但是能够表现出子类的特性(调用子类的函数或方法)。
多态分为静态多态与动态多态，静态多态即使我不讲，你也已经会用了(只是你自己不知道)；动态多态的实现需要两个关键技术：父类对子类的引用；子类重定义父类的虚函数。
在Java中，父类对子类的引用很自然，就像声明一个对象一样，而在C++中必须使用指针；另外Java中没有修饰符的函数都默认为虚函数，所以在子类中只需要重定义父类函数即可，而C++必须显示加上virtual修饰符，再重定义才可以。
下面分别是C++多态实现和Java多态实现。

C++

class A
{
public:
    virtual void show()
    {
        cout <<"A";
    }
};
class B:public A
{
public:
    void show()
    {
        cout << "B";
    }

};
int main()
{
    A*p = new B();
    p->show();
}

运行之后输出B，可以看出A的指针却调用了B类中的show函数。

Java

public class A {
    public void show()
    {
        System.out.println("A");
    }   
} 
public class B extends A{  
    public void show()
    {
        System.out.println("B");
    }   
    static public void main(String[]args){
        A p=new B();
        p.show();

    }

}  

运行结果同样为B

以上为原创部分，割；接下来就要在理解清楚概念的基础上来点小练习了，下面的例子为转载，也很经典。

---

首先是Java的继承经典题目。引用自深入理解Java多态性

public class A {
    public String show(D obj) {
        return ("A and D");
    }

    public String show(A obj) {
        return ("A and A");
    } 

}

public class B extends A{
    public String show(B obj){
        return ("B and B");
    }

    public String show(A obj){
        return ("B and A");
    } 
}

public class C extends B{

}

public class D extends B{

}

public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();

        System.out.println(a1.show(b));   ①
        System.out.println(a1.show(c));   ②
        System.out.println(a1.show(d));   ③
        System.out.println(a2.show(b));   ④
        System.out.println(a2.show(c));   ⑤
        System.out.println(a2.show(d));   ⑥
        System.out.println(b.show(b));    ⑦
        System.out.println(b.show(c));    ⑧
        System.out.println(b.show(d));    ⑨     
    }
}


答案：
              ①   A and A
              ②   A and A
              ③   A and D
              ④   B and A
              ⑤   B and A
              ⑥   A and D
              ⑦   B and B
              ⑧   B and B
              ⑨   A and D

具体解释大家可以阅读原文，已经解释的十分清楚了，我想重点强调的是调用的优先问题 ，优先级由高到低依次为：this.show(Object)、super.show(O)、this.show((super)O)、super.show((super)O)。

接下来是C++的多态题目，引用自从一个面试题谈C++多态性

class A
{
public:
    void foo()
    {
        printf("1\n");
    }
    virtual void fun()
    {
        printf("2\n");
    }
};
class B : public A
{
public:
    void foo()
    {
        printf("3\n");
    }
    void fun()
    {
        printf("4\n");
    }
};
int main(void)
{
    A a;
    B b;
    A *p = &a;
    p->foo();
    p->fun();
    p = &b;
    p->foo();
    p->fun();
    return 0;
}

答案：1214