Feiticeiros e guerreiros

Herança

Em C#, pode definir-se uma hierarquia de classes através da herança, que permite a uma classe derivada (Car) herdar o comportamento e os dados da sua classe base (Vehicle). Se não for especificada nenhuma classe base, a classe herda da classe object.

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

• Definir um método normal.
• Definir um método virtual, que é como um método normal, mas que as classes derivadas podem alterar.
• Definir um método abstract, que é um método sem implementação que as classes derivadas têm de implementar. Uma classe com métodos abstract também tem de ser marcada como abstract. As classes abstratas não podem ser instanciadas.

O modificador de acesso protected permite aceder a um membro de uma classe base a partir de uma classe derivada, mas bloqueia o acesso a partir de outras classes.

As classes derivadas podem aceder aos membros da classe base através 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 vai chamar automaticamente o construtor da classe base antes de executar a lógica do seu próprio construtor. Podem passar-se argumentos ao construtor de uma classe base através da 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 do que uma classe deriva de uma classe base, as duas (ou mais) classes implementam frequentemente versões diferentes de um método da classe base. Este é um princípio muito importante chamado polimorfismo. Por exemplo, numa variação do exemplo acima, mostramos como o código que usa Vehicle pode alterar o seu comportamento consoante o 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