¿Cómo difiere el comportamiento virtual predeterminado en C++ y Java?

Analicemos cómo el comportamiento virtual predeterminado de los métodos es opuesto en C++ y Java. Es muy importante recordar que en el lenguaje C++ los métodos miembro de la clase no son virtuales por defecto. Se pueden hacer virtuales mediante el uso de palabras clave virtuales . Por ejemplo, Base::show() no es virtual en el siguiente programa y el programa imprime “Base::show() llamado” . 

Ejemplo:

// C++ Program to Illustrate How
// Default Virtual Behave
// Different in C++ and Java
  
// Importing required libraries
// Input output stream
#include <iostream>
  
using namespace std;
  
// Class 1
// Superclass
class Base {
  
    // Granting public access via
    // public access modifier
public:
    // In c++, non-virtual by default
    // Method of superclass
    void show()
    {
  
        // Print statement
        cout << "Base::show() called";
    }
};
  
// Class 2
// Subclass
class Derived : public Base {
  
    // Granting public access via public access modifier
public:
    // Method of subclass
    void show()
    {
  
        // Print statement
        cout << "Derived::show() called";
    }
};
  
// Main driver method
int main()
{
    // Creating object of subclass
    Derived d;
    
    // Creating object of subclass
    // with different reference
    Base& b = d;
  
    // Calling show() method over
    // Superclass object
    b.show();
  
    getchar();
  
    return 0;
}

Salida: error de compilación

Base::show() called

Salida Explicación: Agregar virtual antes de la definición de Base::show() hace que el programa imprima «Derivado::show() llamado». En Java, los métodos son virtuales por defecto y se pueden convertir en no virtuales usando la palabra clave final . Por ejemplo, en el siguiente programa java, show() es virtual por defecto y el programa imprime «Derivado::show() llamado «.

Veamos qué sucede en el caso de que usemos el mismo concepto en un lenguaje de programación java a través del ejemplo que se propone a continuación.

Ejemplo:

// Java Program to Illustrate
// How Default Virtual Behave
// Different in C++ and Java
  
// Importing required classes
import java.util.*;
  
// Class 1
// Helper class
class Base {
  
    // Method of sub class
    // In java, virtual by default
    public void show()
    {
  
        // Print statement
        System.out.println("Base::show() called");
    }
}
  
// Class 2
// Helper class extending Class 1
class Derived extends Base {
  
    // Method
    public void show()
    {
  
        // Print statement
        System.out.println("Derived::show() called");
    }
}
  
// Class 3
// Main class
public class GFG {
  
    // Main driver method
    public static void main(String[] args)
    {
  
        // Creating object of superclass with
        // reference to subclass object
        Base b = new Derived();
        ;
  
        // Calling show() method over Superclass object
        b.show();
    }
}

Derived::show() called

Nota: A diferencia del comportamiento no virtual de C++, si agregamos final antes de la definición de show() en Base , entonces el programa anterior falla en la compilación.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.