Trilhas
/
C#
C#
/
Programa
/
Herança
He

Herança em C#

3 exercícios

Sobre 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 nenhuma classe pai for especificada, 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 de outras classes. Assim, as classes derivadas podem acessar membros public e protected da classe pai, mas não membros private da classe pai.

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

// 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 vai chamar automaticamente o construtor da sua classe pai antes de executar a lógica do seu próprio construtor. É possível passar argumentos para o construtor da classe pai usando a palavra-chave base. Como classes abstratas não podem ser instanciadas, 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 de uma classe deriva de uma classe base, as duas (ou mais) subclasses 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

Para impedir que uma classe seja herdada, adicione o modificador sealed. Alguns profissionais tentam evitar herdar de classes concretas (como discutido nesta pergunta do SO) e o modificador sealed apoia essa abordagem. Por outro lado, muitos desenvolvedores de C# consideram esse recurso um obstáculo à manutenção, como discutido em alguns dos comentários desta pergunta. O conselho é usar o modificador sealed com moderação até você ganhar confiança no seu uso para as suas necessidades.

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

Editar via GitHub O link abre em uma nova janela ou aba

Aprenda Herança

A prática está bloqueada

Desbloqueie mais 1 exercício para praticar Herança