He

Herança em C#

3 exercícios

Sobre Herança

Em C#, uma hierarquia de classes pode ser definida recorrendo a herança, que permite que uma classe derivada (Car) herde 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 que um membro de uma classe base seja acedido numa classe derivada, mas bloqueia o acesso a partir de outras classes. Assim, as classes derivadas podem aceder a membros public e protected da classe base, mas não a membros private da classe base.

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();
}

// Cannot be inherited from
sealed 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 base antes de executar a lógica do seu próprio construtor. Os argumentos podem ser passados ao construtor da classe base com a palavra-chave base. Como as classes abstratas não podem ser instanciadas, os seus construtores podem ser definidos como protected.

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) subclasses 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 mudar 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

Para impedir que uma classe seja herdada, acrescenta o modificador sealed. Alguns programadores tentam evitar herdar de classes concretas (como se discute nesta pergunta do SO) e o modificador sealed apoia essa abordagem. Por outro lado, muitos programadores de C# consideram-nos um obstáculo à manutenção, como se discute em alguns dos comentários desta pergunta. O conselho é usar o modificador sealed com moderação, até ganhares confiança na sua utilização para as tuas necessidades.

O seguinte artigo descreve new como alternativa ao modificador override. Isto é ocasionalmente útil, talvez com hierarquias de classes complicadas e/ou algum tipo de conflito entre bibliotecas.

Editar via GitHub A ligação abre numa nova janela ou separador

Aprende Herança

A prática está bloqueada

Desbloqueia mais 1 exercício para praticares Herança