默认虚拟行为在C++和Java中有什么不同？

在面向对象编程中，重载、覆盖和多态是非常重要的概念。在C++和Java中，它们的实现方式有所不同，特别是在默认虚拟行为上，这篇文章将阐述C++和Java的不同实现。

虚函数和纯虚函数

在C++中，通过将一个成员函数声明为虚函数，可以实现面向对象的多态性和动态绑定，它是在运行时而不是编译时才进行解析和调用。

class Shape {
  public:
    virtual void draw(); //声明虚函数
    virtual double area() = 0; //声明纯虚函数
};

class Circle : public Shape {
  public:
    void draw() override { //覆盖Shape的虚函数
        // 绘制圆形
    }
    double area() override { //必须实现纯虚函数
        // 计算面积
    }
};

在上面的示例中，Shape类声明了一个虚函数和一个纯虚函数，Circle类继承自Shape类并覆盖其虚函数，同时必须实现纯虚函数。

在Java中，所有的函数都可以被覆盖，没有C++中的纯虚函数的概念。而且，默认情况下，所有的函数都是虚函数，除非使用关键字final将其声明为非虚函数。

abstract class Shape {
    public void draw() { //声明虚函数
        // 绘制形状
    }
    abstract double area(); //声明抽象方法
}

class Circle extends Shape {
    @Override
    public void draw() { //覆盖父类的虚函数
        // 绘制圆形
    }
    @Override
    public double area() { //实现抽象方法
        // 计算面积
    }
}

在上面的示例中，Shape类声明了一个虚函数和一个抽象方法，Circle类继承自Shape类并覆盖其虚函数和实现抽象方法。

默认虚函数行为

在C++中，如果在子类中没有覆盖基类的虚函数，则基类的虚函数会被默认地调用。

class Shape {
  public:
    virtual void draw() { //声明虚函数
        // 绘制形状
    }
    virtual double area() { //声明虚函数
        // 计算面积
    }
};

class Circle : public Shape {
};

int main() {
    Circle circle;
    circle.draw(); //继承Shape类的draw函数
    circle.area(); //继承Shape类的area函数
    return 0;
}

在上面的示例中，Circle类没有覆盖Shape类的虚函数，因此默认调用了Shape类的虚函数。

在Java中，如果在子类中没有覆盖基类的虚函数，则没有任何操作。

class Shape {
    public void draw() { //虚函数
        // 绘制形状
    }
    public double area() { //虚函数
        // 计算面积
    }
}

class Circle extends Shape {
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.draw(); //仅继承Shape类的draw函数
        circle.area(); //仅继承Shape类的area函数
    }
}

在上面的示例中，Circle类没有覆盖Shape类的虚函数，因此没有任何操作。

虚函数的析构函数

在使用虚函数时，使用虚析构函数可以避免内存泄漏和资源泄漏等问题。在C++和Java中，虚析构函数的实现方式有所不同。

在C++中，如果声明了一个虚析构函数，则在使用delete运算符时会自动调用子类的析构函数。如果没有声明虚析构函数，则只会调用基类的析构函数，这可能会导致内存泄漏。

class Shape {
  public:
    virtual ~Shape() { //声明虚析构函数
        // 释放资源
    }
};

class Circle : public Shape {
  public:
    ~Circle() { //定义析构函数
        // 释放资源
    }
};

int main() {
    Shape* shape = new Circle();
    delete shape; //调用Circle的析构函数
    return 0;
}

在上面的示例中，Shape类声明了虚析构函数，Circle类继承了Shape类并定义了自己的析构函数，使用new运算符在堆上创建了Circle对象，使用delete运算符释放了shape指针，调用了Circle类的析构函数。

在Java中，所有的类都有默认析构函数，不需要手动定义。Java也提供了垃圾回收机制，自动控制内存的释放，而不需要像C++一样手动释放。

class Shape {
    public void dispose() { //实现虚析构函数
        // 释放资源
    }
}

class Circle extends Shape {
    @Override
    public void dispose() { //覆盖父类的虚析构函数
        // 释放资源
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape = new Circle();
        shape.dispose(); //调用Circle的dispose函数
    }
}

在上面的示例中，Shape类实现了虚析构函数的功能，并定义了自己的dispose函数，Circle类继承了Shape类并覆盖了dispose函数，使用new运算符创建了Circle对象，使用dispose函数释放了shape对象，调用了Circle类的dispose函数。

结论

在C++和Java中，使用虚函数实现面向对象编程的多态性和动态绑定，但在默认虚拟行为上有所不同。在C++中，如果子类没有覆盖基类的虚函数，则默认调用基类的虚函数；如果使用虚析构函数，则在使用delete运算符时会自动调用子类的析构函数。而在Java中，默认情况下所有函数都是虚函数，如果子类没有覆盖基类的虚函数，则不会有任何操作；所有类都有默认析构函数，不需要手动定义，并且Java的垃圾回收机制可以自动处理内存释放问题，而不需要像C++一样手动释放。