Como funcionam herança e polimorfismo?

Question

Accepted Answer

**Herança** permite que uma classe derive de uma classe base, reutilizando e estendendo seus membros. **Polimorfismo** permite tratar objetos derivados através de um tipo base, com o método sobrescrito correto chamado em tempo de execução (via `virtual`/`override`). Estes são mecanismos centrais de POO em C#.

## Herança

```csharp
public class Animal
{
    public string Name { get; set; }
    public virtual string MakeSound() => "some sound";   // virtual — can be overridden
}

public class Dog : Animal     // Dog inherits from Animal (single inheritance)
{
    public override string MakeSound() => "Woof";        // OVERRIDE the base method
    public void Fetch() => Console.WriteLine("fetching");
}

var dog = new Dog { Name = "Rex" };
dog.Name;          // inherited from Animal
dog.MakeSound();    // "Woof"
```

Uma classe derivada (`Dog : Animal`) herda os membros da base e pode adicionar os seus próprios. C# suporta **herança simples** (uma única classe base). `base.Method()` chama a implementação da base.

## Polimorfismo — virtual / override

```csharp
// treat different derived types through the base type; the ACTUAL type's method runs
List<Animal> animals = new() { new Dog(), new Cat() };
foreach (Animal a in animals)
    Console.WriteLine(a.MakeSound());   // "Woof", "Meow" — runtime dispatch
```

**Polimorfismo**: um método `virtual` sobrescrito em classes derivadas é despachado em **tempo de execução** baseado no tipo real do objeto — então a mesma chamada (`a.MakeSound()`) faz coisas diferentes por tipo. Isto permite código flexível e extensível (manipular muitos tipos uniformemente).

## Classes abstratas e sealed

```csharp
public abstract class Shape
{
    public abstract double Area();        // abstract — derived MUST implement, no body
    public string Describe() => $"Area: {Area()}";   // concrete shared method
}
public class Circle : Shape
{
    public double Radius { get; set; }
    public override double Area() => Math.PI * Radius * Radius;
}
// var s = new Shape();   // ❌ can't instantiate an abstract class

public sealed class Final { }   // sealed — cannot be inherited from
```

**Classes abstratas** definem uma base parcial (com métodos abstratos que subclasses devem implementar mais código compartilhado); `sealed` impede herança adicional.

## Por que isso importa

Herança e polimorfismo são mecanismos centrais de POO em C#, fundamentais para design orientado a objetos e para trabalhar com o framework .NET (que os utiliza extensivamente), então entendê-los é essencial. **Herança** fornece reutilização de código via relações "é um" (um Dog é um Animal), embora C# permita apenas herança simples. **Polimorfismo** — através de `virtual`/`override` e despacho de método em tempo de execução — é particularmente importante: permite tratar diferentes tipos derivados uniformemente através de um tipo base enquanto o comportamento correto específico do tipo executa automaticamente, possibilitando designs flexíveis e extensíveis (processar uma coleção de formas diferentes, cada uma calculando sua própria área).

Entender o mecanismo `virtual`/`override` (a base marca um método como sobrescritível, classes derivadas o sobrescrevem, e o runtime despacha para a versão do tipo real), **classes abstratas** (bases parciais com métodos que subclasses devem implementar mais código compartilhado), e `sealed` (impedindo herança) é necessário para projetar hierarquias de classes e para entender como o framework .NET e bibliotecas são estruturados.

Já que herança e polimorfismo sustentam C# orientado a objetos e o framework em si, e já que polimorfismo em tempo de execução é um habilitador chave de código extensível e mantível, dominar estes — especialmente o despacho virtual/override que faz polimorfismo funcionar — é conhecimento importante e frequentemente aplicado para design orientado a objetos em C#, e um tópico comum de entrevista que revela compreensão dos fundamentos de POO.