virtual/override/sealed y clases abstractas
Aprenda los métodos virtuales, la sobrescritura, el sellado de sobrescrituras y las clases abstractas; vea cómo las referencias a la clase base distribuyen la ejecución a las implementaciones derivadas.
virtual/override/sealed y clases abstractas es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 3 lecciones en total.
Conceptos básicos de herencia
Objetivo: reutilizar y personalizar el comportamiento mediante la herencia.
- virtual en la clase base
- override en la clase derivada
- sealed override para impedir cambios posteriores
- abstract class define un contrato y código compartido
virtual y override
virtual permite sobrescribir. Las llamadas mediante una referencia a la clase base usan la implementación override de la clase 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 fijar un método en un nivel determinado de la jerarquía.
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");
}
}
Clases abstractas
Las clases abstract definen miembros obligatorios (abstract) y también pueden proporcionar código compartido.
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 frente a abstract
Elija:
- virtual: proporcione un cuerpo predeterminado que los tipos derivados puedan sobrescribir.
- abstract: no tiene cuerpo; los tipos derivados deben implementarlo.
- sealed override: impida más sobrescrituras una vez fijado el comportamiento.
Llamadas polimórficas
Polimorfismo: un método acepta el tipo base y llama a los miembros sobrescritos en las instancias 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");
}
}
Regla de virtual, override y sealed
Repaso
Repaso: marque los métodos de la clase base como virtual, sobrescríbalos en los tipos derivados y use sealed override para fijar el comportamiento. Use abstract classes para exigir implementaciones y compartir código común.
Preguntas frecuentes
¿La lección «virtual/override/sealed y clases abstractas» es gratis?
Sí — el texto completo de «virtual/override/sealed y clases abstractas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 3 lecciones en total.
¿Qué aprenderé en «virtual/override/sealed y clases abstractas»?
Aprenda los métodos virtuales, la sobrescritura, el sellado de sobrescrituras y las clases abstractas; vea cómo las referencias a la clase base distribuyen la ejecución a las implementaciones derivad… Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C# Academy?
No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 3.
¿Cuánto tiempo toma la lección «virtual/override/sealed y clases abstractas»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C# Academy?
Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- virtual/override/sealed y clases abstractas
- Interfaces (introducción) e implementación de varias interfaces
- Polimorfismo y distribución dinámica