virtual/override/sealed; classes abstratas
Aprenda métodos virtuais, substituição, selagem de substituições e classes abstratas; veja como referências à classe base fazem o despacho para implementações derivadas.
virtual/override/sealed; classes abstratas é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 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.
Fundamentos da herança
Objetivo: reutilizar e personalizar comportamentos por meio da herança.
- virtual na classe base
- override na classe derivada
- sealed override para impedir novas alterações
- classe abstract define um contrato e código compartilhado
virtual e override
virtual permite a substituição. Chamadas por meio de uma reference da classe base usam o override da classe derivada (despacho dinâmico).
using System;
// Base method is virtual so derived classes can customize it
public class Shape
{
public virtual double Area()
{
return 0.0; // default
}
}
public class Rectangle : Shape
{
public int Width { get; private set; }
public int Height { get; private set; }
public Rectangle(int w, int h)
{
Width = w; Height = h;
}
public override double Area()
{
return Width * Height;
}
}
public class Program
{
public static void Main(string[] args)
{
Shape s = new Shape();
Shape r = new Rectangle(3, 4); // base reference
Console.WriteLine("Shape area = " + s.Area());
Console.WriteLine("Rectangle area = " + r.Area()); // calls Rectangle.Area()
}
}
sealed override
Use sealed override para bloquear um método em determinado nível da hierarquia.
using System;
public class BaseLogger
{
public virtual string Prefix()
{
return "[LOG]";
}
}
public class ConsoleLogger : BaseLogger
{
public sealed override string Prefix()
{
return "[CONSOLE]";
}
}
// Further derived class cannot override Prefix again:
// public class FancyLogger : ConsoleLogger
// {
// public override string Prefix() { return "[FANCY]"; } // compile error
// }
public class Program
{
public static void Main(string[] args)
{
ConsoleLogger log = new ConsoleLogger();
Console.WriteLine(log.Prefix() + " Ready");
}
}
Classes abstratas
Classes abstratas definem membros obrigatórios (abstract) e também podem fornecer código compartilhado.
using System;
// Abstract class: cannot be instantiated; must implement abstract members
public abstract class Animal
{
public abstract string Speak(); // no body here
public string Info()
{
return "Animal says: " + Speak(); // shared code uses the abstract member
}
}
public class Dog : Animal
{
public override string Speak()
{
return "Woof";
}
}
public class Program
{
public static void Main(string[] args)
{
// Animal a = new Animal(); // compile error: abstract
Animal d = new Dog();
Console.WriteLine(d.Info()); // calls Dog.Speak()
}
}
virtual versus abstract
Escolha:
- virtual: forneça um corpo padrão que os tipos derivados possam substituir.
- abstract: não possui corpo; os tipos derivados devem implementá-lo.
- sealed override: impeça novas substituições quando o comportamento estiver definido.
Chamadas polimórficas
Polimorfismo: um método aceita o tipo base e chama membros substituídos nas instâncias derivadas.
using System;
public class Notifier
{
public virtual string Channel() { return "Base"; }
}
public class EmailNotifier : Notifier
{
public override string Channel() { return "Email"; }
}
public class SmsNotifier : Notifier
{
public override string Channel() { return "SMS"; }
}
public class Program
{
// Works with any Notifier (polymorphism)
static void Send(Notifier n, string msg)
{
Console.WriteLine("[" + n.Channel() + "] " + msg);
}
public static void Main(string[] args)
{
Send(new EmailNotifier(), "Hello");
Send(new SmsNotifier(), "Hi");
}
}
Regra de virtual, override e sealed
Recapitulação
Recapitulação: marque os métodos da classe base como virtual, use override nos tipos derivados e use sealed override para bloquear o comportamento. Use classes abstratas para exigir implementações e compartilhar código comum.
Perguntas Frequentes
A aula “virtual/override/sealed; classes abstratas” é grátis?
Sim — o texto completo de “virtual/override/sealed; classes abstratas” é 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 “virtual/override/sealed; classes abstratas”?
Aprenda métodos virtuais, substituição, selagem de substituições e classes abstratas; veja como referências à classe base fazem o despacho para implementações derivadas. 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 1 de 3.
Quanto tempo leva a aula “virtual/override/sealed; classes abstratas”?
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
- virtual/override/sealed; classes abstratas
- Interfaces (introdução) e implementação de várias interfaces
- Polimorfismo e despacho dinâmico