Programa C# para demostrar una clase abstracta con herencia de varios niveles

Abstract Class es la forma de lograr la abstracción. Es una clase especial que nunca se instancia directamente. Esta clase debe contener al menos un método abstracto y marcar por palabra clave abstracta en la definición de clase. El objetivo principal de esta clase es dar un modelo para las clases derivadas y establecer algunas reglas que deben implementar las clases derivadas cuando heredan una clase abstracta. Una clase abstracta se puede utilizar como clase base y todas las clases derivadas deben implementar las definiciones abstractas. 

Sintaxis :

abstract class classname
{
    // Method Declaration in abstract class
}

Aquí, el nombre de clase es el nombre de una clase abstracta. Podemos declarar cualquier número de métodos dentro de él.

La herencia de múltiples niveles es un tipo de herencia en la que una clase derivada heredará una clase base y la clase derivada también se comportará como la clase base para otra clase. Por ejemplo, tenemos tres clases llamadas clase1, clase2 y clase3. Aquí, class3 se deriva de class2 y class2 se deriva de class1.

Sintaxis :

class GFG : Abstract_Class
{
    // Method definition for abstract method
}

Herencia multinivel para clases abstractas

Dada una clase abstracta, nuestra tarea es implementar la clase abstracta en la clase principal y luego implementar la herencia multinivel. Entonces, entendamos con la ayuda de un ejemplo.

class GFG : Abstract_class
{
   // Method definition for abstract method
}

// First child class extends parent
class GFG2 : GFG
{
    // Method definition
}

// Second child class extends first child class
class GFG3 : GFG2
{
    // Method definition
}

Aquí, GFG es la clase principal y GFG2 y GFG3 son la clase secundaria que amplía la clase principal.

Ejemplo :

// C# program to illustrate abstract class 
// with multiple-level Inheritance
using System;
  
// Abstract class
abstract class Abstract_class
{
      
    // Method declaration for abstract class
    public abstract void abstract_method();
}
  
// Parent class
class GFG : Abstract_class
{
      
    // Method definition for abstract method
    public override void abstract_method()
    {
        Console.WriteLine("Abstract method is called");
    }
}
  
// First child class extends parent
class GFG2 : GFG
{
      
    // Method definition
    public void Mymethod1()
    {
        Console.WriteLine("Method from GFG2 class");
    }
}
  
// Second child class extends first child class
class GFG3 : GFG2
{
      
    // Method definition
    public void Mymethod2()
    {
        Console.WriteLine("Method from GFG3 class");
    }
}
  
class Geeks{
      
// Driver code
public static void Main(String[] args)
{
      
    // Creating an object of GFG3 class
    GFG3 obj = new GFG3();
      
    // Call the methods using GFG3 class
    obj.abstract_method();
    obj.Mymethod1();
    obj.Mymethod2();
}
}

Producción:

Abstract method is called
Method from GFG2 class
Method from GFG3 class

Explicación: En este ejemplo, creamos una clase Abstract llamada «Abstract_class» y declaramos un método llamado «abstract_method» dentro de ella. Luego creamos una clase principal llamada «GFG» anulando el método de una clase abstracta. Después de eso, creamos la primera clase secundaria llamada «GFG2» que hereda la clase principal y definimos un método llamado «Mymethod1» dentro de ella. Luego creó una segunda clase secundaria llamada «GFG3» que hereda la primera clase secundaria y definió un método «Mymethod2» dentro de ella. Finalmente, creamos la clase principal que incluye el método principal, luego creamos un objeto (llamado «obj») para la segunda clase secundaria y llamamos a todos los métodos que se declaran y obtienen el resultado en la pantalla.