Ejemplos de polimorfismo en C#

En esta entrada trataremos sobre el concepto del polimorfismo y daremos unos ejemplos.

Contenido

1. Polimorfismo usando clases
2. Polimorfismo usando interfaces

El polimorfismo se refiere a la posibilidad de definir múltiples clases con funcionalidad diferente, pero con métodos o propiedades denominados de forma idéntica.

Polimorfismo usando clases

Por ejemplo, tenemos una clase Empleado y otra clase Alumno, las cuales heredan de una clase abstracta Persona que tiene el metodo Saludar. En las clases hijas sobreescribiremos el metodo Saludar devolviendo el nombre de la persona y si es un empleado o un alumno.

namespace notasensistemas.blogspot.com
{
    public abstract class Persona
    {
        public string Nombre { get; set; }

        public abstract string Saludar();
    }
    public class Alumno : Persona
    {
        public Alumno(string nombre)
        {
            this.Nombre = nombre;
        }
        public override string Saludar()
        {
            string saludo = "Hola, mi nombre es " + this.Nombre + " y soy un alumno";
            return saludo;
        }
    }
    public class Empleado : Persona
    {
        public Empleado(string nombre)
        {
            this.Nombre = nombre;
        }
        public override string Saludar()
        {
            string saludo = "Hola, mi nombre es " + this.Nombre + " y soy un empleado";
            return saludo;
        }
    }
}

En vez de tener un arreglo de empleados y otro de alumnos por separado, usaremos el polimorfismo con un solo arreglo de personas, al cual agregaremos un alumno y un empleado para luego iterar y llamar al metodo saludar.

Persona[] personas = new Persona[2];
personas[0] = new Alumno("Jaime Correa");
personas[1] = new Empleado("Juan Perez");
for (int i = 0; i < personas.Length; i++)
{
     Console.WriteLine(personas[i].Saludar());
}

El resultado es el siguiente:

Hola, mi nombre es Jaime Correa y soy un alumno
Hola, mi nombre es Juan Perez y soy un alumno

Como podemos observar, a pesar de que tengamos un unico arreglo de objetos de tipo persona, cuando llamamos al metodo saludar, los objetos se comportan como un objeto de tipo alumno o un objeto de tipo empleado.

Polimorfismo usando interfaces

De la misma manera que en el ejemplo anterior, en vez de usar una clase padre Persona de la cual heredan las clases hijas Empleado y Alumno podemos definir una interfaz IPersona que defina el metodo Despedirse, y que las clases Empleado y Alumno implementen la interfaz IPersona.

public interface IPersona
    {
        String Despedirse();
    }
    public class Alumno : IPersona
    {
        public Alumno(string nombre)
        {
            this.Nombre = nombre;
        }
        public string Despedirse()
        {
            string adios = "El alumno " + this.Nombre + " se despide cordialmente";
            return adios;
        }
    }
    public class Empleado : IPersona
    {
        public Empleado(string nombre)
        {
            this.Nombre = nombre;
        }
        public string Despedirse()
        {
            string adios = "El empleado " + this.Nombre + " se despide cordialmente";
            return adios;
        }
    }

De la misma manera que en el ejemplo anterior, podemos instanciar un arreglo de tipo IPersona, agregar objetos que implementen la interfaz IPersona: un objeto alumno o un objeto empleado, para luego iterar y llamar al metodo Despedirse.

IPersona[] personas = new IPersona[2];
personas[0] = new Alumno("Jaime Correa");
personas[1] = new Empleado("Juan Perez");
for (int i = 0; i < personas.Length; i++)
{
    Console.WriteLine(personas[i].Despedirse());
}

El resultado es el siguiente:

El alumno Jaime Correa se despide cordialmente
El empleado Juan Perez se despide cordialmente

Fuente: Polymorphism