0Pricing
C# Academy · Aula

Polimorfismo e despacho dinâmico

Entenda o polimorfismo: chame membros virtuais por meio de uma referência à classe base, use coleções tipadas pela classe base, evite ocultar métodos e faça conversões de tipo com segurança quando necessário.

Polimorfismo e despacho dinâmico é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 3 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 3 aulas no total.

Visão geral do polimorfismo

Objetivo: use um único tipo base e permita que os tipos derivados personalizem o comportamento.

  • Reference da classe base, objeto derivado
  • virtual + override → despacho dinâmico
  • Coleções tipadas pela classe base
  • Evite ocultar métodos com new

Fundamentos do despacho dinâmico

Chamar um método virtual usa o tipo de execução do objeto, não o tipo da variável em tempo de compilação.

using System;

public class Animal
{
  public virtual string Speak() { return "???"; }
}

public class Cat : Animal
{
  public override string Speak() { return "Meow"; }
}

public class Dog : Animal
{
  public override string Speak() { return "Woof"; }
}

public class Program
{
  public static void Main(string[] args)
  {
    Animal a1 = new Cat(); // base reference
    Animal a2 = new Dog();
    Console.WriteLine(a1.Speak()); // Meow
    Console.WriteLine(a2.Speak()); // Woof
  }
}

Polimorfismo em coleções

Armazene tipos derivados diferentes em uma List<Base> e chame os membros virtuais de maneira uniforme.

using System;
using System.Collections.Generic;

public class Shape
{
  public virtual double Area() { return 0.0; }
}

public class Rectangle : Shape
{
  private readonly int _w, _h;
  public Rectangle(int w, int h) { _w = w; _h = h; }
  public override double Area() { return _w * _h; }
}

public class Circle : Shape
{
  private readonly int _r;
  public Circle(int r) { _r = r; }
  public override double Area() { return 3.14159 * _r * _r; }
}

public class Program
{
  public static void Main(string[] args)
  {
    List<Shape> shapes = new List<Shape>();
    shapes.Add(new Rectangle(3, 4));
    shapes.Add(new Circle(2));

    foreach (Shape s in shapes)
    {
      Console.WriteLine("Area = " + s.Area()); // calls correct override
    }
  }
}

Ocultação versus override

Evite a ocultação de métodos (new). Use override para obter polimorfismo real; a ocultação chama a versão da classe base por meio de uma reference da classe base.

using System;

public class Printer
{
  public virtual void Print() { Console.WriteLine("[Base]"); }
}

public class LoudPrinter : Printer
{
  public override void Print() { Console.WriteLine("[LOUD]"); }
}

public class HiddenPrinter : Printer
{
  // Hides the base method instead of overriding (BAD fit for polymorphism)
  public new void Print() { Console.WriteLine("[HIDDEN]"); }
}

public class Program
{
  public static void Main(string[] args)
  {
    Printer a = new LoudPrinter();
    Printer b = new HiddenPrinter();

    a.Print(); // [LOUD]  (override works)
    b.Print(); // [Base]  (hiding fails via base reference)
  }
}

Conversão segura (as + verificação)

Prefira chamadas à classe base e virtuais. Se for necessário usar membros exclusivos do tipo derivado, faça uma conversão segura (as + verificação de nulo).

using System;

public class Vehicle
{
  public virtual string Info() { return "Vehicle"; }
}

public class Car : Vehicle
{
  public bool HasAirConditioning;
  public override string Info() { return "Car"; }
}

public class Program
{
  public static void Main(string[] args)
  {
    Vehicle v = new Car();
    Console.WriteLine(v.Info()); // polymorphic call

    // Need a Car-only member? Cast carefully using 'as'
    Car c = v as Car;
    if (c != null)
    {
      c.HasAirConditioning = true;
      Console.WriteLine("AC set: " + c.HasAirConditioning);
    }
    else
    {
      Console.WriteLine("Not a Car");
    }
  }
}

Dicas de polimorfismo

Dicas:

  • Projete primeiro pensando em chamadas à classe base e virtuais.
  • Use override, não new, para alterar o comportamento.
  • Mantenha as APIs da classe base pequenas e estáveis.
  • Faça conversões raramente; prefira polimorfismo ou interfaces.

Significado do despacho dinâmico

Verificação rápida: o que significa despacho dinâmico em C#?

Recapitulação

Recapitulação: o polimorfismo permite que uma chamada à classe base alcance vários comportamentos derivados por meio de virtual/override. Use coleções tipadas pela classe base, evite a ocultação com new e faça conversões somente quando necessário.

Perguntas Frequentes

A aula “Polimorfismo e despacho dinâmico” é grátis?

Sim — o texto completo de “Polimorfismo e despacho dinâmico” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 3 aulas no total.

O que vou aprender em “Polimorfismo e despacho dinâmico”?

Entenda o polimorfismo: chame membros virtuais por meio de uma referência à classe base, use coleções tipadas pela classe base, evite ocultar métodos e faça conversões de tipo com segurança quando ne… Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 3.

Quanto tempo leva a aula “Polimorfismo e despacho dinâmico”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. virtual/override/sealed; classes abstratas
  2. Interfaces (introdução) e implementação de várias interfaces
  3. Polimorfismo e despacho dinâmico
← Voltar para C# Academy