Magos y guerreros

Herencia

En C#, se puede definir una jerarquía de clases usando la herencia, que permite que una clase derivada (Car) herede el comportamiento y los datos de su clase padre (Vehicle). Si no se especifica un padre, la clase hereda de la clase object.

Las clases padre pueden proporcionar funcionalidad a las clases derivadas de tres maneras:

• Definir un método normal.
• Definir un método virtual, que es como un método normal pero que las clases derivadas sí pueden cambiar.
• Definir un método abstract, que es un método sin implementación que las clases derivadas deben implementar. Una clase con métodos abstract también debe marcarse como abstract. Las clases abstractas no se pueden instanciar.

El modificador de acceso protected permite acceder a un miembro de la clase padre desde una clase derivada, pero bloquea el acceso desde otras clases.

Las clases derivadas pueden acceder a los miembros de la clase padre mediante la palabra clave base.

// Inherits from the 'object' class
abstract class Vehicle
{
    // Can be overridden
    public virtual void Drive()
    {
    }

    // Must be overridden
    protected abstract int Speed();
}

class Car : Vehicle
{
    public override void Drive()
    {
        // Override virtual method

        // Call parent implementation
        base.Drive();
    }

    protected override int Speed()
    {
        // Implement abstract method
    }
}

El constructor de una clase derivada llamará automáticamente al constructor de su clase padre antes de ejecutar la lógica de su propio constructor. Se pueden pasar argumentos al constructor de una clase padre usando la palabra clave base:

abstract class Vehicle
{
    protected Vehicle(int wheels)
    {
        Console.WriteLine("Called first");
    }
}

class Car : Vehicle
{
    public Car() : base(4)
    {
        Console.WriteLine("Called second");
    }
}

Cuando más de una clase deriva de una clase base, esas dos (o más) clases suelen implementar versiones distintas de un método de la clase base. Este es un principio muy importante llamado polimorfismo. Por ejemplo, en una variación del ejemplo anterior mostramos cómo el código que usa Vehicle puede cambiar su comportamiento según qué tipo de vehículo se haya instanciado.

abstract class Vehicle
{
   public abstract string GetDescription();
}

class Car : Vehicle
{
   public Car()
   {
   }

   public override string GetDescription()
   {
      return "Runabout";
   }
}

class Rig : Vehicle
{
   public Rig()
   {
   }

   public override string GetDescription()
   {
      return "Big Rig";
   }
}

Vehicle v1 = new Car();
Vehicle v2 = new Rig();

v1.GetDescription();
// => Runabout
v2.GetDescription();
// => Big Rig