C++虚函数与JAVA抽象函数的比较

曾经终败给现在 2021-12-09 02:34 207阅读 0赞

*C++的基础语法比Java的更加复杂且灵活。*  
**C++—————Java  
虚函数 -------- 普通函数  
纯虚函数 -------- 抽象函数  
抽象类 -------- 抽象类  
纯虚类 -------- 接口**

## C++: ##

C++采用了静态连编和动态连编相结合的方法。编译时多态性(静态连编)主要是通过函数重载和运算符重载实现的，运行时多态性(动态连编)主要是通过虚函数实现的。

C++中的普通函数不可以被重写，如果函数不是虚函数，则调用某个函数，是根据当前指针类型判断的并不是指针所指向的对象的类型。如果派生类重写了基类的虚函数，则调用某个函数，是根据当前指针所指向的对象的类型判断的。

抽象类是至少有一个纯虚函数的类。也就是说，如果类有一个虚函数没有实现，它就是抽象类。抽象类不可直接声明对象，如果派生类继承基类但未实现其中的纯虚函数，则派生类仍为抽象类。  
声明纯虚函数的一般形式为：`virtual 函数类型 函数名(参数表)=0;`

class Person
    {
        
    public:
        virtual void eat(){
        }
        virtual void walk()
        {
        
            cout<<"我会走路"<<endl;
        }
        virtual void look()=0;
    };

C++提供多继承的功能，还有不同的继承方式。实际上，是因为C++的多继承功能带来了麻烦，当一个派生类继承两个基类，而这两个基类又来自一个相同的基类时，就会造成原始基类数据和函数的二义性，所以会有虚基类，在访问这些同名成员时，必须在派生类对象名后增加直接基类名，使其唯一地标识一个成员，以免产生二义性。

#include<iostream>
    using namespace std;
    class Bird
    {
        
    public:
        Bird()
        {
        
            water=100;
        }
        void show()
        {
        
            cout<<"水杯里还有"<<water<<"ml的水"<<endl;
        }
        virtual void drink(){
        }
    protected:
        int water;
    };
    
    class Crow:virtual public Bird
    {
        
    public:
        Crow()
        {
        
            water=water-5;
        }
    };
    
    class Sparrow:virtual public Bird
    {
        
    public:
        Sparrow()
        {
        
            water=water-10;
        }
    };
    
    class birdDrink:public Crow,public Sparrow
    {
        
    public:
        void drink()
        {
        
            water=water-20;
        }
    
    };
    
    int main()
    {
        
        Bird *p;
        birdDrink bd;
        p=&bd;
        p->drink();
        p->show();
        return 0;
    }

Bird派生Crow和Sparrow类时，使用关键字virtual将类Bird声明为虚基类，birdDrink继承它们时就共用一个变量water。（例子举得不太好23333）

## JAVA: ##

Java中，如果函数不是抽象函数，而是一个普通函数，它是默认实现类似C++中虚函数功能的，也就是说，调用某个函数，是根据当前对象的类型来判断的。如果函数是抽象函数，则相当于C++中的纯虚函数，没有具体的方法实现。

Java的抽象类需要通过abstract关键字声明，在Java的抽象类中，可以有抽象方法也可以没有抽象方法。抽象类同样不可直接声明对象。

abstract class Person{
        
    	public void eat(){
        }
    	public void walk(){
        
    		System.out.println("我会走路");
    	}
    	abstract void look();
    }

而java只提供单继承，为了模拟多继承功能就提供了接口，一个类可以实现(implements)多个接口(interface)。在java的接口中，函数类型都默认为"public abstract"类型，而变量类型默认为"public static final"类型。java中的接口就类似于C++中的纯虚类，即类体内的函数都是纯虚函数，如果变量也都设置成static final就更像了。

interface studyLanguage{
        
        //变量前默认加上public static final
    	int wordNumber=3500;
    	int grammarNumber=150;
    	//方法前默认加上public abstract
    	void listen();
    	void speak();
    	void read();
    	void write();
    }

在C++中类似于：

class studyLanguage
    {
        
    public:
        static const int wordNumber=3500;
        static const int grammarNumber=150;
        virtual void listen()=0;
        virtual void speak()=0;
        virtual void read()=0;
        virtual void write()=0;
    };