C# Herencia

La herencia es uno de los conceptos más importantes en la programación orientada a objetos. La herencia nos permite definir una clase basándonos en otra, lo que facilita la creación y el mantenimiento de aplicaciones. También favorece la reutilización de código y ahorra tiempo de desarrollo.

Al crear una clase, el programador no necesita reescribir por completo nuevos miembros de datos y funciones miembro; solo necesita diseñar una nueva clase que herede los miembros de la clase existente. Esta clase existente se denominaclase base, y esta nueva clase se denominaclase derivada。

La idea de la herencia implementa la relación depertenencia (IS-A). Por ejemplo, un mamíferopertenece a (IS-A)un animal, un perropertenece a (IS-A)un mamífero, por lo tanto un perropertenece a (IS-A)un animal.

Clase base y clase derivada

Una clase puede heredar de otra clase, denominándose clase base (clase padre) y clase derivada (clase hija).

C# no admite la herencia múltiple de clases, pero admite la herencia múltiple de interfaces; una clase puede implementar múltiples interfaces.

En resumen:Una clase puede heredar de múltiples interfaces, pero solo puede heredar de una clase.

La sintaxis para crear una clase derivada en C# es la siguiente:

<modificador de acceso> class <clase base>
{
 ...
}
class <clase derivada> : <clase base>
{
 ...
}

La clase derivada hereda los miembros de la clase base (campos, métodos, propiedades, etc.), a menos que estén marcados explícitamente como privados (private).

La clase derivada puede invocar los constructores y métodos de la clase base mediante la palabra clave base.

Ejemplo

class BaseClass
{
    public void SomeMethod()
    {
        // Method implementation
    }
}

class DerivedClass : BaseClass
{
    public void AnotherMethod()
    {
        // Accessing base class method
        base.SomeMethod();
       
        // Method implementation
    }
}

Supongamos que hay una clase base Shape y su clase derivada es Rectangle:

Ejemplo

using System;
namespace InheritanceApplication
{
   class Shape
   {
      public void setWidth(int w)
      {
         width = w;
      }
      public void setHeight(int h)
      {
         height = h;
      }
      protected int width;
      protected int height;
   }

   // Clase derivada
   class Rectangle: Shape
   {
      public int getArea()
      {
         return (width * height);
      }
   }
   
   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle Rect = new Rectangle();

         Rect.setWidth(5);
         Rect.setHeight(7);

         // Imprime el área del objeto
         Console.WriteLine("Área total: {0}",  Rect.getArea());
         Console.ReadKey();
      }
   }
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

总面积: 35

Inicialización de la clase base

La clase derivada hereda las variables miembro y los métodos miembro de la clase base. Por lo tanto, el objeto de la clase padre debe crearse antes de que se cree el objeto de la clase hija. Puede realizar la inicialización de la clase padre en la lista de inicialización de miembros.

El siguiente programa demuestra esto:

Ejemplo

using System;
namespace RectangleApplication
{
   class Rectangle
   {
      // Variables miembro
      protected double length;
      protected double width;
      public Rectangle(double l, double w)
      {
         length = l;
         width = w;
      }
      public double GetArea()
      {
         return length * width;
      }
      public void Display()
      {
         Console.WriteLine("Longitud: {0}", length);
         Console.WriteLine("Ancho: {0}", width);
         Console.WriteLine("Área: {0}", GetArea());
      }
   }//end class Rectangle  
   class Tabletop : Rectangle
   {
      private double cost;
      public Tabletop(double l, double w) : base(l, w)
      { }
      public double GetCost()
      {
         double cost;
         cost = GetArea() * 70;
         return cost;
      }
      public void Display()
      {
         base.Display();
         Console.WriteLine("Costo: {0}", GetCost());
      }
   }
   class ExecuteRectangle
   {
      static void Main(string[] args)
      {
         Tabletop t = new Tabletop(4.5, 7.5);
         t.Display();
         Console.ReadLine();
      }
   }
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

长度: 4.5
宽度: 7.5
面积: 33.75
成本: 2362.5

Herencia de interfaces (Interface Inheritance)

Una interfaz puede heredar de una o más interfaces; la interfaz derivada hereda todos los miembros de la interfaz base.

La interfaz derivada puede ampliar la lista de miembros de la interfaz base, pero no puede cambiar sus modificadores de acceso.

Ejemplo

interface IBaseInterface
{
    void Method1();
}

interface IDerivedInterface : IBaseInterface
{
    void Method2();
}

El ejemplo de herencia de interfaces se puede implementar de la siguiente manera:

Ejemplo

using System;

// Define una interfaz base
interface IBaseInterface
{
    void Method1();
}

// Define una interfaz derivada que hereda de la interfaz base
interface IDerivedInterface : IBaseInterface
{
    void Method2();
}

// Clase que implementa la interfaz derivada
class MyClass : IDerivedInterface
{
    public void Method1()
    {
        Console.WriteLine("Method1 implementation");
    }

    public void Method2()
    {
        Console.WriteLine("Method2 implementation");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Crea una instancia de la clase MyClass
        MyClass obj = new MyClass();

        // Llama al método heredado de la interfaz base
        obj.Method1();

        // Llama al método nuevo de la interfaz derivada
        obj.Method2();
    }
}

En el ejemplo anterior, la clase MyClass implementa la interfaz IDerivedInterface, por lo que debe proporcionar todos los métodos definidos en IDerivedInterface, incluido el método Method1() heredado de IBaseInterface. En el método Main, creamos una instancia obj de MyClass y llamamos a sus métodos.

El resultado es:

Method1 implementation
Method2 implementation

C# Herencia múltiple

La herencia múltiple se refiere a la capacidad de una clase de heredar comportamientos y características de más de una clase padre al mismo tiempo. En contraste con la herencia única, que se refiere a que una clase solo puede heredar de una clase padre.

C# no admite la herencia múltiple. Sin embargo, puede utilizar interfaces para implementar la herencia múltiple. El siguiente programa demuestra esto:

Ejemplo

using System;
namespace InheritanceApplication
{
   class Shape
   {
      public void setWidth(int w)
      {
         width = w;
      }
      public void setHeight(int h)
      {
         height = h;
      }
      protected int width;
      protected int height;
   }

   // Clase base PaintCost
   public interface PaintCost
   {
      int getCost(int area);

   }
   // Clase derivada
   class Rectangle : Shape, PaintCost
   {
      public int getArea()
      {
         return (width * height);
      }
      public int getCost(int area)
      {
         return area * 70;
      }
   }
   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle Rect = new Rectangle();
         int area;
         Rect.setWidth(5);
         Rect.setHeight(7);
         area = Rect.getArea();
         // Imprime el área del objeto
         Console.WriteLine("Área total: {0}",  Rect.getArea());
         Console.WriteLine("Costo total de pintura: ${0}" , Rect.getCost(area));
         Console.ReadKey();
      }
   }
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

总面积: 35
油漆总成本: $2450
Otras extensiones