Java与C++中多态的实现方法，并举例实现

Java中的多态性。

1.方法重载（overload） 

概念：简单的说:方法重载就是类的同一种功能的多种实现方式，到底采用哪种方式，取决于调用者给出的参数。  

注意事项： 

（1）方法名相同 

（2）方法的参数类型、个数、顺序不至少有一项不同 

（3）方法返回类型可以不同 

（4）方法的修饰符可以不同 

如果只是返回类型不一样，不能够构成重载 

如果只是控制访问修饰符号不一样，也是不能构成重载的 

Overloaded的方法是可以改变返回值的类型。 

2.方法覆盖（override） 

概念：简单的说：方法覆盖就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的那个方法。 

注意事项：方法覆盖有很多条件，总的讲有两点一定要注意： 

（1）子类的方法的返回类型，参数，方法名称，要和父类方法的返回类型，参数，方法名称完全一样，否则编译出错。 

（2） 子类方法不能缩小父类方法的访问权限（反过来是可以的） 

举例实现：

override

class A{ 

public int getVal(){ 

return(5); 

} 

} 

class B extends A{ 

public int getVal(){ 

return(10); 

} 

} 

public class override { 

public static void main(String[] args) { 

B b = new B(); 

A a= (A)b;//把 b 强 制转换成A的类型 

int x=a.getVal(); 

System.out.println(x); 

} 

} 

overload

class OverloadDemo { 

void test(){ 

System.out.println("NO parameters"); 

} 

void test(int a){ 

System.out.println("a:"+a); 

}//end of Overload test for one integer parameter. 

void test(int a, int b){ 

System.out.println("a and b:"+a+" "+b); 

} 

double test(double a){ 

System.out.println("double a:"+a); 

return a*a; 

} 

} 

class Overload{ 

public static void main(String[] args) { 

OverloadDemo ob = new OverloadDemo(); 

double result; 

ob.test(); 

ob.test(10); 

ob.test(10, 20); 

result = ob.test(123.25); 

System.out.println("Result of ob.test(123.25):"+result); 

} 

} 

详细出处参考：http://www.jb51.net/article/32239.html

C++中的多态性。

Overload(重载)：在C++程序中，可以将语义、功能相似的几个函数用同一个名字表示，但参数或返回值不同（包括类型、顺序不同），即函数重载。

（1）相同的范围（在同一个类中）；

（2）函数名字相同；

（3）参数不同；

Override(覆盖)：是指派生类函数覆盖基类函数，特征是：

（1）不同的范围（分别位于派生类与基类）；

（2）函数名字相同；

（3）参数相同；

（4）基类函数必须有virtual 关键字。

Overwrite(重写)：是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。

（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。

#include <cstdio>  

#include <iostream>   

class Parent  

{  

public:  

    void F()  

    {  

        printf("Parent.F()\n");  

    }  
    virtual void G()  

    {  

        printf("Parent.G()\n");  

    }  

    int Add(int x, int y)  

    {  

        return x + y;  

    }  

    //重载(overload)Add函数   

    float Add(float x, float y)  

    {  

        return x + y;  

    }  

};  

  

class ChildOne:Parent    //注意ChildOne子类中的成员函数全部是private的,也就是说实例出来的对象都不能调用这些方法

{  

    //重写(overwrite)父类函数   

    void F()  

    {  

        printf("ChildOne.F()\n");   

    }  

    //覆写(override)父类虚函数,主要实现多态   

    void G()  

    {  

        printf("ChildOne.G()\n");  

    printf("invoke private F() in ChildOne class\n"); //同一个类内的函数是可以自由相互调用的! 因为这些函数与类对象无关!

       F();

    }  

};  

  

  

int main()  

{  

    ChildOne childOne;   //在栈内存上建立一个名为childOne的类对象

// ChildOne* pchildOne = new ChildOne();  
 //在堆内存上建立一个类对象, 区别是一定要通过其指针pchildOne来访问该对象

//childOne.F(); //由于F()在ChildOne类中是个private的,故不能在类外面调用!

    Parent* p = (Parent*) &childOne; 

 // Parent* p = (Parent*) pchildOne;

    //调用Parent.F()，overwrite后的函数必须用子类对象调用 

    p->F();  
    //实现多态, 通过override 父类的虚函数
    p->G();  //父类中G()是一个public的,通过多态用父类指针调用子类的private函数

    Parent* p2 = new Parent();  

    //重载(overload)   

    printf("%d\n", p2->Add(1, 2));  

    printf("%f\n", p2->Add(3.4f, 4.5f));  

    delete p2;  
bb03

delete pchildOne; //将堆上的对象析构掉

    return 0;  

}  

例2.override实现多态-----通过覆盖虚函数

#include <iostream>

using namespace std;

class A 

{ 

public: 

virtual void Func1(void){ cout<< "This is A::Func1 \n";} 

}; 

void Test(A *a)  //注意Test不是类中的方法,故不用new出一个类对象

{ 

a->Func1(); 

} 

class B : public A 

{ 

public: 

virtual void Func1(void){ cout<< "This is B::Func1 \n";}   // 这里的virtual可以去掉,但B的子类就不能override Func1了

}; 

class C : public A 

{ 

public: 

virtual void Func1(void){ cout<< "This is C::Func1 \n";} 

}; 

int main()

{ 

  A a; 

B b; 

C c; 

 //注意Test不是类中的方法,故不用new出一个类对象 

Test(&a); // 输出This is A::Func1 

Test(&b); // 输出This is B::Func1

Test(&c); // 输出This is C::Func1 

  return 0;

}