Magos e guerreiros

Herança

Em C#, uma hierarquia de classes pode ser definida usando herança, que permite que uma classe derivada (Car) herde o comportamento e os dados da sua classe pai (Vehicle). Se nenhum pai for especificado, a classe herda da classe object.

As classes pai podem fornecer funcionalidade às classes derivadas de três formas:

• Definir um método comum.
• Definir um método virtual, que é como um método comum, mas que as classes derivadas podem alterar.
• Definir um método abstract, que é um método sem implementação que as classes derivadas precisam implementar. Uma classe com métodos abstract também precisa ser marcada como abstract. Classes abstratas não podem ser instanciadas.

O modificador de acesso protected permite que um membro da classe pai seja acessado em uma classe derivada, mas bloqueia o acesso a partir de outras classes.

As classes derivadas podem acessar membros da classe pai por meio da palavra-chave 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
    }
}

O construtor de uma classe derivada chama automaticamente o construtor da classe pai antes de executar a lógica do próprio construtor. É possível passar argumentos para o construtor de uma classe pai usando a palavra-chave base:

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

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

Quando mais de uma classe deriva de uma classe base, essas duas (ou mais) classes costumam implementar versões diferentes de um método da classe base. Esse é um princípio muito importante chamado polimorfismo. Por exemplo, em uma variação do exemplo acima, mostramos como um código que usa Vehicle pode mudar de comportamento dependendo do tipo de veículo que foi 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