Herencia
La herencia en C# es un principio fundamental de la programación orientada a objetos que permite que una clase (clase derivada) herede atributos y métodos de otra clase (clase base). Este mecanismo fomenta la reutilización de código, facilita el mantenimiento y la escalabilidad de aplicaciones complejas, y permite modelar relaciones del tipo “es un” (is-a), como por ejemplo, un objeto Car es un tipo de Vehicle.
La herencia se utiliza en C# para extender la funcionalidad de clases existentes, implementar polimorfismo y gestionar el comportamiento de objetos a través de una interfaz común. Conceptos clave incluyen métodos virtuales (virtual), sobrescritura de métodos (override), clases abstractas (abstract) y clases selladas (sealed).
En este tutorial, aprenderás a crear clases base y derivadas, sobrescribir métodos, aplicar polimorfismo y diseñar sistemas complejos con una estructura lógica y mantenible. También se abordarán buenas prácticas, optimización del rendimiento y prevención de errores comunes, garantizando aplicaciones seguras y fáciles de mantener. Comprender la herencia es crucial para construir arquitecturas escalables e integrar componentes de manera eficiente en proyectos de C#.
Ejemplo Básico
textusing System;
// Clase base
class Vehicle
{
public string Brand { get; set; }
public int Year { get; set; }
public virtual void DisplayInfo()
{
Console.WriteLine($"Vehicle: {Brand}, Year: {Year}");
}
}
// Clase derivada
class Car : Vehicle
{
public int Doors { get; set; }
public override void DisplayInfo()
{
Console.WriteLine($"Car: {Brand}, Year: {Year}, Doors: {Doors}");
}
}
class Program
{
static void Main(string\[] args)
{
Vehicle vehicle = new Vehicle { Brand = "Toyota", Year = 2020 };
vehicle.DisplayInfo();
Car car = new Car { Brand = "Honda", Year = 2021, Doors = 4 };
car.DisplayInfo();
}
}En este ejemplo, Vehicle es la clase base con propiedades Brand y Year, y un método virtual DisplayInfo(). El uso de virtual permite que las clases derivadas sobrescriban este método.
Car hereda de Vehicle, añade la propiedad Doors y sobrescribe DisplayInfo() usando override para mostrar información específica de la clase derivada. Este ejemplo ilustra cómo la herencia permite reutilizar código, extender funcionalidades y aplicar polimorfismo. En proyectos reales, este enfoque simplifica la creación de jerarquías de objetos y la gestión de su comportamiento de manera consistente y mantenible.
Ejemplo Práctico
textusing System;
using System.Collections.Generic;
// Clase base: Product
class Product
{
public string Name { get; set; }
public decimal Price { get; set; }
public virtual void Display()
{
Console.WriteLine($"Product: {Name}, Price: {Price:C}");
}
}
// Clase derivada: Electronics
class Electronics : Product
{
public int WarrantyMonths { get; set; }
public override void Display()
{
Console.WriteLine($"Electronics: {Name}, Price: {Price:C}, Warranty: {WarrantyMonths} months");
}
}
// Clase derivada: Food
class Food : Product
{
public DateTime ExpiryDate { get; set; }
public override void Display()
{
Console.WriteLine($"Food: {Name}, Price: {Price:C}, Expiry: {ExpiryDate:yyyy/MM/dd}");
}
}
class Store
{
private List<Product> products = new List<Product>();
public void AddProduct(Product product)
{
products.Add(product);
}
public void ShowProducts()
{
foreach (var product in products)
{
product.Display();
}
}
}
class Program
{
static void Main(string\[] args)
{
Store store = new Store();
store.AddProduct(new Electronics { Name = "Smartphone", Price = 1500m, WarrantyMonths = 24 });
store.AddProduct(new Food { Name = "Milk", Price = 5.5m, ExpiryDate = DateTime.Now\.AddMonths(1) });
store.ShowProducts();
}
}Product es la clase base con métodos y propiedades comunes. Electronics y Food heredan Product, agregan propiedades específicas y sobrescriben Display() para mostrar información personalizada.
La clase Store gestiona una colección de productos, y el polimorfismo permite que una referencia de la clase base invoque métodos de objetos derivados. Este patrón se aplica ampliamente en sistemas de inventario, tiendas en línea y cualquier aplicación que requiera tratar distintos tipos de objetos de manera uniforme, manteniendo la extensibilidad y claridad del código.
Buenas prácticas y errores comunes:
- Colocar propiedades y métodos comunes en la clase base usando virtual o abstract.
- Evitar jerarquías demasiado profundas para no complicar el mantenimiento.
- Gestionar correctamente los recursos para evitar fugas de memoria.
- Implementar manejo de excepciones adecuado.
- Considerar el uso de interfaces o composición para mayor flexibilidad.
- Encapsular datos y aplicar medidas de seguridad adecuadas.
📊 Tabla de Referencia
| C# Element/Concept | Description | Usage Example |
|---|---|---|
| Class | Definición de clase base o derivada | class Vehicle { public string Brand; } |
| Inheritance | Creación de jerarquías de clases | class Car : Vehicle { public int Doors; } |
| Virtual Method | Método que puede ser sobrescrito | public virtual void Display() { } |
| Override | Sobrescritura de método de clase base | public override void Display() { } |
| Polymorphism | Llamada a método de derivado a través de referencia de base | Vehicle v = new Car(); v.Display(); |
El aprendizaje de la herencia permite centralizar comportamientos comunes en clases base, sobrescribirlos en derivadas y aplicar polimorfismo para trabajar de manera uniforme con los objetos. Esto mejora la modularidad, el mantenimiento y la escalabilidad de sistemas.
Se recomienda estudiar a continuación clases abstractas, interfaces y patrones de diseño. La combinación de herencia y composición permite construir arquitecturas sólidas y eficientes. Para profundizar, son útiles la documentación oficial de Microsoft, guías avanzadas y proyectos open-source en C#.
🧠 Pon a Prueba tu Conocimiento
Prueba tu Conocimiento
Pon a prueba tu comprensión de este tema con preguntas prácticas.
📝 Instrucciones
- Lee cada pregunta cuidadosamente
- Selecciona la mejor respuesta para cada pregunta
- Puedes repetir el quiz tantas veces como quieras
- Tu progreso se mostrará en la parte superior