Esta entrada es un complemento a este artículo que redacte tiempo atrás, la cual fue parte de la serie de artículos: Fundamentos de la POO con C#.
En esta entrada analizaremos con ejemplos y teoría cada tipo de polimorfismo que se puede implementar con C# desde un punto de vista práctico, ya que hay varias formas de clasificar al polimorfismo, quizá hayas escuchado hablar de algunos de esos tipos. Inclusive Microsoft nos habla de dos tipos de polimorfismo y lo puedes ver aquí.
Entonces estos 3 tipos de polimorfismo que veremos a continuación son los siguientes:
Polimorfismo por herencia
Este tipo de polimorfismo establece que un objeto de una subclase pueda ser instanciado como uno de la superclase o clase padre.
Esto responde al Principio de Sustitucion de Liskov, de los principios SOLID.
Esta forma de polimorfismo viene de la mano con la herencia. Veámoslo en el siguiente ejemplo:
Tenemos 3 clases: Publicación, libro y artículo.
public class Publicacion
{
//Propiedades
public string Titulo { get; set; }
public string Categoria { get; set; }
public string TipoPublicacion { get; set; }
public string[] Tags { get; set; }
//Métodos
public virtual void Publicar()
{
Console.WriteLine($"Publicacion no especificada.");
}
}
public class Libro : Publicacion
{
//Métodos
public override void Publicar()
{
Console.WriteLine($"Se ha publicado el LIBRO");
}
}
public class Artículo : Publicacion
{
//Métodos
public override void Publicar()
{
Console.WriteLine($"Se ha publicado el ARTÍCULO");
}
}
Como puedes notar las clases Libro y Artículo heredan de Publicación y cada una de ellas sobre-escribe al método Publicar, tomando así el método "muchas formas", de allí el nombre de polimorfismo.
Para que una clase derivada o clase hija sobre-escriba a su clase base o clase padre, se hace uso de las palabras reservadas: virtual en la clase base y override en la clase derivada.
Ahora corramos el programa, será un programa de consola, su clase Program sería así:
Console.WriteLine("4 Pillars! - Polymorphism");
//Polimorfismo por herencia
Publicacion publicacion = new Publicacion();
Publicacion libro = new Libro();
Publicacion articulo = new Artículo();
publicacion.Publicar();
libro.Publicar();
articulo.Publicar();
Y obtenemos el siguiente resultado:
Polimorfismo por abstracción
En este caso el polimorfismo se lleva a cabo mediante convertir a la clase base como abstracta.
Una clase abstracta es aquella que se usa como clase base para otras, aquí hay más información de este tipo de clases 😉
Veamos un ejemplo: Tenemos una clase DocumentoVenta como clase base y a Boleta y Factura que heredan de ella e implementan distintas funcionalidades para sus métodos.
public abstract class DocumentoVenta
{
//Propiedades
public string Serie { get; set; }
public string Correlativo { get; set; }
public decimal Total { get; set; }
//Métodos
public abstract void ProcesarVenta();
}
public class Boleta : DocumentoVenta
{
//Propiedades
public string Nombres { get; set; }
public string Apellidos { get; set; }
//Métodos
public override void ProcesarVenta()
{
Console.WriteLine($"Se procesó la BOLETA por un total de {Total}");
}
}
public class Factura : DocumentoVenta
{
//Propiedades
public string RazonSocial { get; set; }
//Métodos
public override void ProcesarVenta()
{
Console.WriteLine($"Se procesó la FACTURA por un total de {Total}");
}
}
Aquí se está dando diferentes formas a un mismo método por cada clase hija, haciendo uso de una clase y método abstracto, de ahí su nombre: Polimorfismo por abstracción
La clase Program sería así para probar el programa de consola:
Console.WriteLine("4 Pillars! - Polymorphism");
//Polimorfismo por abstracción
DocumentoVenta doc1 = new Boleta();
doc1.Total = 100;
DocumentoVenta doc2 = new Factura();
doc2.Total = 250;
doc1.ProcesarVenta();
doc2.ProcesarVenta();
Polimorfismo por Interface
Una Interfaz es como un contrato a las que las clases que la implementen se obligan a cumplir, o implementar en este caso.
Más información sobre interfaces aquí en esta entrada crack! 🔥
Por ejemplo podemos poner un ejemplo:
En una empresa embotelladora tenemos distintas clases de bebidas produciéndose: gaseosas y néctares, entonces podemos crear una interfaz IBebida y dos clases que la implementen: Gaseosa y Nectar
public interface IBebida
{
void Envasar();
void Empaquetar();
}
public class Gaseosa : IBebida
{
public void Envasar()
{
Console.WriteLine("Gaseosa envasada");
}
public void Empaquetar()
{
Console.WriteLine("Gaseosa empaquetada");
}
}
public class Nectar : IBebida
{
public void Envasar()
{
Console.WriteLine("Nectar envasado");
}
public void Empaquetar()
{
Console.WriteLine("Nectar empaquetado");
}
}
La clase Program sería así:
Console.WriteLine("4 Pillars! - Polymorphism");
//Polimorfismo por interface
Gaseosa gaseosa1 = new Gaseosa();
Gaseosa gaseosa2 = new Gaseosa();
Nectar nectar1 = new Nectar();
Nectar nectar2 = new Nectar();
IBebida[] bebidas = { gaseosa1, gaseosa2, nectar1, nectar2 };
foreach (IBebida bebida in bebidas)
{
bebida.Envasar();
}
Entonces tenemos el siguiente resultado:
Como vemos en este caso se puede hacer que varias clases implementen una interfaz y esto les da la posibilidad de ser tratados como un conjunto y poder iterar en ellas o hacer más operaciones, y cada clase si bien tienen los mismos métodos, cada uno de ellos tienen su propia implementación.
Es una buena práctica comenzar el nombre de una interfaz con la letra I mayúscula como IBebida
Y bueno eso es todo estimado crack! Practica que la pelota ahora está en tu cancha.
Si esta entrada te ha fascinado, entonces compártela pues dev! 🎉😉