Comparación de herencia en C++ y Java

El propósito de la herencia es el mismo en C++ y Java. La herencia se usa en ambos lenguajes para reutilizar código y/o crear una relación ‘es-a’. Los siguientes ejemplos demostrarán las diferencias entre Java y C++ que brindan soporte para la herencia. 

1) En Java, todas las clases heredan de la clase Object directa o indirectamente. Por lo tanto, siempre hay un único árbol de herencia de clases en Java, y la clase de objeto es la raíz del árbol. En Java, al crear una clase, hereda automáticamente de la clase de objeto. Sin embargo, en C++ hay un bosque de clases; cuando creamos una clase que no hereda de otra, creamos un nuevo árbol en un bosque. 

Siguiendo el ejemplo de Java, se muestra que la clase Test se hereda automáticamente de la clase Object. 

class Test {
    // members of test
}
class Main {
    public static void main(String[] args)
    {
        Test t = new Test();
        System.out.println("t is instanceof Object: "
                           + (t instanceof Object));
    }
}

t is instanceof Object: true

2) En Java, los miembros de la clase de los abuelos no son accesibles directamente.  (Consulte este artículo para obtener más detalles). 

3) El significado del especificador de acceso de miembro protegido es algo diferente en Java. En Java, los miembros protegidos de una clase «A» son accesibles en otra clase «B» del mismo paquete, incluso si B no hereda de A (ambos deben estar en el mismo paquete).

Por ejemplo, en el siguiente programa, los miembros protegidos de A son accesibles en B. 

class A {
    protected int x = 10, y = 20;
}
 
class B {
    public static void main(String args[])
    {
        A a = new A();
        System.out.println(a.x + " " + a.y);
    }
}

10 20

4) Java usa ‘extiende’palabras clave para la herencia. A diferencia de C++, Java no proporciona un especificador de herencia como público, protegido o privado. Por lo tanto, no podemos cambiar el nivel de protección de los miembros de la clase base en Java, si algún miembro de datos es público o está protegido en la clase base, permanece público o protegido en la clase derivada. Al igual que C++, los miembros privados de una clase base no son accesibles en una clase derivada. 

A diferencia de C++, en Java no tenemos que recordar esas reglas de herencia que son una combinación del especificador de acceso a la clase base y el especificador de herencia. 

5) En Java, los métodos son virtuales por defecto. En C++, usamos explícitamente palabras clave virtuales (consulte este artículo para obtener más detalles).

6) Java usa una interfaz de palabra clave separada para interfaces y palabras clave abstractas para clases abstractas y funciones abstractas.

A continuación se muestra un ejemplo de clase abstracta de Java,

// An abstract class example
abstract class myAbstractClass {
 
    // An abstract method
    abstract void myAbstractFun();
 
    // A normal method
    void fun() { System.out.println("Inside My fun"); }
}
 
public class myClass extends myAbstractClass {
    public void myAbstractFun()
    {
        System.out.println("Inside My fun");
    }
}

El siguiente es un ejemplo de interfaz de Java, 
 

// An interface example
public interface myInterface {
   
    // myAbstractFun() is public
     // and abstract, even if we
    // don't use these keywords
    void myAbstractFun();
    // is same as public abstract void myAbstractFun()
}
 
// Note the implements keyword also.
public class myClass implements myInterface {
    public void myAbstractFun()
    {
        System.out.println("Inside My fun");
    }
}

7) A diferencia de C++, Java no admite herencias múltiples. Una clase no puede heredar de más de una clase. Sin embargo, una clase puede implementar múltiples interfaces.

8) En C++, el constructor predeterminado de la clase principal se llama automáticamente, pero si queremos llamar a un constructor parametrizado de una clase principal, debemos usar la lista de inicializadores . Al igual que C++, el constructor predeterminado de la clase principal se llama automáticamente en Java, pero si queremos llamar al constructor parametrizado, debemos usar super para llamar al constructor principal. Consulte el siguiente ejemplo de Java.

package main;
 
class Base {
    private int b;
    Base(int x)
    {
        b = x;
        System.out.println("Base constructor called");
    }
}
 
class Derived extends Base {
    private int d;
    Derived(int x, int y)
    {
        // Calling parent class parameterized constructor
        // Call to parent constructor must be the first line
        // in a Derived class
        super(x);
        d = y;
        System.out.println("Derived constructor called");
    }
}
 
class Main {
    public static void main(String[] args)
    {
        Derived obj = new Derived(1, 2);
    }
}

Producción

Base constructor called
Derived constructor called

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