Java和C++的虚函数的异同

 

 

　　参考博客：点我

　　

　　要点：Java中的普通函数默认为虚函数，因此动态绑定的行为是默认的，而C++必须将方法声明为虚函数(virtual关键字)，执行时才会进行动态绑定，详细区别可参考代码以及注释。

　　代码大致：实现父类 Animal类，包含数据成员 姓名和年龄，以及实现eat方法和informa方法，子类Dog类继承于Animal，并实现方法的覆盖。Java和C++中都没有显示声明为虚函数，但观察输出结果可知，Java中实现了动态绑定，而C++没有，只有将相应函数加上virtual关键字，才实现动态绑定。这就是Java和C++处理的不同之处

C++代码：

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;

class Animal{
public:
    char name[20];
    int age;

    Animal(){
        age = 0;
        name[0] = 0;
    }

    Animal(char* nName, char nAge){
        strcpy(name, nName);
        age = nAge;
    }

    void eat(){
        printf("Animal can eat!
");
    }

    //可在此加上virtual关键字观察输出区别
    void information(){
        printf("%s is a Animal, it's %d years old!
", name, age);
    }
};

class Dog :public Animal{

public:
    Dog() :Animal(){}
    Dog(char* nName, int nAge) :Animal(nName, nAge){}

    void eat(){
        printf("Dog can eat!
");
    }

    void information(){
        printf("%s is a Dog, it's %d years old!
", name, age);
    }
};


int main()
{
    Animal* A = new Animal("A", 10);
    Animal* B = new Dog("B", 20);

    A->information();
    //C++必须显示声明为虚函数才能实现多态 否则只是调用父类的方法而不会调用子类的
    B->information(); 


    return 0;
}

Java代码：

Animal类：

package com.hao;

public class Animal {
    String name = "";
    int age = 0;
    
    Animal(){}

    /**
     * @param name 动物的姓名
     * @param age 动物的年龄
     */
    public Animal(String name, int age) {
        super(); //其super类其实为Object类
        this.name = name;
        this.age = age;
    }
    
    public void eat(){
        System.out.println("Animal can eat!");
    }
    
    public void information(){
        System.out.printf("%s is a Animal, it's %d years old!
", name, age);
    }
    
    

}//Animal

Dog类：

package com.hao;

public class Dog extends Animal {

    /**
     * 默认构造函数
     */
    public Dog() {
        super();
        // TODO 自动生成的构造函数存根
    }

    /**
     * @function 带参构造函数
     * @param name 狗的姓名
     * @param age 狗的年龄
     */
    public Dog(String name, int age) {
        super(name, age);
        // TODO 自动生成的构造函数存根
    }

    /* （非 Javadoc）
     * @see com.hao.Animal#eat()
     */
    @Override
    public void eat() {
        // TODO 自动生成的方法存根
        //super.eat();
        System.out.println("Dog can eat!");
    }

    /* （非 Javadoc）
     * @see com.hao.Animal#information()
     */
    @Override
    public void information() {
        // TODO 自动生成的方法存根
        //super.information();
        System.out.printf("%s is a Dog, it's %d years old!
", name, age);
    }

    
}

包含主函数的Main类：

package com.hao;

public class Main {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Animal A = new Animal("A", 10);
        Animal B = new Dog("B", 20);
        
        A.information();
        B.information(); //Java中默认使用动态绑定---区别于C++
        
        A.eat();
        B.eat();
        
    }

}