Programa C# para implementar la herencia múltiple mediante la interfaz y la clase abstractas

Dada la herencia múltiple, ahora nuestra tarea es implementar la herencia múltiple con la ayuda de una clase e interfaz abstractas. Entonces, antes de la implementación, en primer lugar, aprendemos la definición básica de herencia múltiple, clase abstracta e interfaz. 

Herencia múltiple: la herencia múltiple es un tipo de herencia que se sigue en los lenguajes de programación orientados a objetos como C#, C++, etc. En esta herencia particular, una clase hereda las propiedades de más de una clase principal. Por ejemplo, en la figura dada, la clase base se hereda de dos clases base, Padre 1 y Padre 2.

Fig: Base que hereda Padre 1 y Padre 2

Clase abstracta: para comprender la clase abstracta, primero comprendamos qué es la abstracción en C#. La abstracción en C# es un proceso para representar la única información necesaria para el mundo exterior. En palabras simples, en este proceso, los detalles de fondo permanecen ocultos y solo la funcionalidad es visible para el mundo exterior. 

Ahora que somos conscientes de la abstracción, volvamos al tema de la clase abstracta . La clase abstracta en C# es un camino para lograr la abstracción en C#. Una clase abstracta no se puede instanciar directamente. Esta clase debe tener al menos un método abstracto. El propósito de usar una clase abstracta en un programa es proporcionar un modelo para la clase derivada y establecer algunos parámetros que la clase derivada debe implementar.

Interfaz: una interfaz es similar a una clase en C#. Pero a diferencia de una clase, una interfaz debe tener solo las declaraciones (o prototipo) de sus miembros.

• Las interfaces significan qué debe hacer una clase y cómo.
• No puede haber ningún miembro privado en una interfaz.
• Todos los miembros de la interfaz son públicos y abstractos (por defecto).
• Para definir una interfaz debemos usar la palabra clave ‘interfaz’.
• Los campos no se pueden proporcionar a una interfaz porque representan una implementación particular de datos.
• Con la ayuda de las interfaces, es posible la herencia múltiple.

Ahora aprendemos cómo implementar la herencia múltiple usando una clase abstracta y una interfaz con la ayuda de un ejemplo:

Ejemplo:En este programa, creamos una clase abstracta myAbstractClass y una interfaz myInterfaceClass, y clases de dos padres myClass1, myClass2. Donde estamos anulando el método abstracto print1() en la clase myClass1 e implementando print2() de la interfaz myInterfaceClass en la clase myClass2. Después de eso, creamos una clase secundaria myClass3, ahora heredamos la clase myClass1 y la interfaz myInterfaceClass. En la clase myClass3, creamos el objeto de la clase myClass1 y myClass2 y aquí definimos dos métodos más, print1(), print2(), y llamamos a print1() de la clase myClass1 dentro del método print1() de myClass3, y llamamos a print2() de la clase myClass2 dentro del método print2() de myClass3. El método Main() es el origen de cualquier programa.

// C# program to implement multiple inheritance
// using abstract class and interface
using System;
 
// Defining an abstract class
abstract class myAbstractClass
{
     
    // Method Declaration
    public abstract void print1();
}
 
// Parent class
class myClass1 : myAbstractClass
{
     
    // Overriding print1() method of myAbstractClass
    public override void print1()
    {
        Console.WriteLine("print1() called");
    }
}
 
interface myInterfaceClass
{
     
    // Method Declaration
    void print2();
}
 
// Another Parent class
class myClass2 : myInterfaceClass
{
    public void print2()
    {
        Console.WriteLine("print2() called");
    }
}
 
// Base class
class myClass3 : myClass1, myInterfaceClass
{
    myClass1 S1 = new myClass1();
    myClass2 S2 = new myClass2();
 
    // Overriding print1() method of myAbstractClass
    public override void print1()
    {
        S1.print1();
    }
     
    public void print2()
    {
        S2.print2();
    }
}
 
// Driver code
class GFG{
 
static public void Main()
{
     
    // Instantiate an object of myClass3
      myClass3 myObject = new myClass3();
 
    myObject.print1();
    myObject.print2();
}
}

print1() called
print2() called