¿Cómo funcionan la herencia y el polimorfismo?

Question

Accepted Answer

**Herencia** permite que una clase derive de una clase base, reutilizando y extendiendo sus miembros. **Polimorfismo** permite tratar objetos derivados a través de un tipo base, con el método sobrescrito correcto llamado en tiempo de ejecución (mediante `virtual`/`override`). Estos son mecanismos OOP fundamentales en C#.

## Herencia

```csharp
public class Animal
{
    public string Name { get; set; }
    public virtual string MakeSound() => "some sound";   // virtual — can be overridden
}

public class Dog : Animal     // Dog inherits from Animal (single inheritance)
{
    public override string MakeSound() => "Woof";        // OVERRIDE the base method
    public void Fetch() => Console.WriteLine("fetching");
}

var dog = new Dog { Name = "Rex" };
dog.Name;          // inherited from Animal
dog.MakeSound();    // "Woof"
```

Una clase derivada (`Dog : Animal`) hereda los miembros de la base y puede añadir los suyos propios. C# soporta **herencia simple** (una sola clase base). `base.Method()` llama a la implementación base.

## Polimorfismo — virtual / override

```csharp
// treat different derived types through the base type; the ACTUAL type's method runs
List<Animal> animals = new() { new Dog(), new Cat() };
foreach (Animal a in animals)
    Console.WriteLine(a.MakeSound());   // "Woof", "Meow" — runtime dispatch
```

**Polimorfismo**: un método `virtual` sobrescrito en clases derivadas se despacha en **tiempo de ejecución** basándose en el tipo real del objeto — así la misma llamada (`a.MakeSound()`) hace cosas diferentes según el tipo. Esto permite código flexible y extensible (manejar muchos tipos uniformemente).

## Clases abstractas y sealed

```csharp
public abstract class Shape
{
    public abstract double Area();        // abstract — derived MUST implement, no body
    public string Describe() => $"Area: {Area()}";   // concrete shared method
}
public class Circle : Shape
{
    public double Radius { get; set; }
    public override double Area() => Math.PI * Radius * Radius;
}
// var s = new Shape();   // ❌ can't instantiate an abstract class

public sealed class Final { }   // sealed — cannot be inherited from
```

**Clases abstractas** definen una base parcial (con métodos abstractos que las subclases deben implementar más código compartido); `sealed` previene herencia adicional.

## Por qué es importante

La herencia y el polimorfismo son mecanismos OOP fundamentales en C#, básicos para el diseño orientado a objetos y para trabajar con el framework .NET (que los utiliza extensamente), por lo que comprenderlos es esencial. **Herencia** proporciona reutilización de código mediante relaciones "es-un" (un Dog es un Animal), aunque C# solo permite herencia simple. **Polimorfismo** — a través de `virtual`/`override` y despacho de métodos en tiempo de ejecución — es particularmente importante: permite tratar diferentes tipos derivados uniformemente a través de un tipo base mientras el comportamiento correcto específico del tipo se ejecuta automáticamente, permitiendo diseños flexibles y extensibles (procesar una colección de diferentes formas, cada una calculando su propia área).

Comprender el mecanismo `virtual`/`override` (la base marca un método como sobrescribible, las clases derivadas lo sobrescriben, y el tiempo de ejecución despacha a la versión del tipo real), **clases abstractas** (bases parciales con métodos que las subclases deben implementar más código compartido), y `sealed` (previniendo herencia) es necesario para diseñar jerarquías de clases y para entender cómo se estructura el framework .NET y sus librerías.

Ya que la herencia y el polimorfismo sustentan C# orientado a objetos y el framework en sí, y ya que el polimorfismo en tiempo de ejecución es un factor clave para código extensible y mantenible, dominar estos — especialmente el despacho virtual/override que hace funcionar el polimorfismo — es conocimiento importante y frecuentemente aplicado para diseño orientado a objetos en C#, y un tema común en entrevistas que revela comprensión de fundamentos OOP.