Un poco de Polimorfismo en C#

En lo que respecta a Programación Orientada a Objetos , basicamente y en simples terminos el polimorfismo nos permite (que en tiempo de ejecucion) los objetos puedan responder a un mismo mensaje de diferentes maneras, dependiendo de como los «interroguemos»…

Podemos identificar  3 tipos de polimorfismo:

Polimorfismo por herencia:  Este tipo de polimorfismo refiere a cuando hereda de una clase normalmente, pero la clase que hereda re-define o mejor dicho sobreescribe (override) a el/los metodos/propiedades la clase base.

Podemos verlo en un sencillo ejemplo de la Clase Base Persona y de la Clase derivada llamada Estudiante.

Polimorfismo por Herencia:

class Persona
 {
   protected string nombre;

   public Persona(string Nombre)
   {
    nombre = Nombre;
   }

   public virtual string Identificar()   // <--- AQUI !
   {
    return nombre + " es persona";
   }
 }

---

class Estudiante:Persona
 {
   public Estudiante(string nombre): base(nombre)
    { }

   public override string Identificar()   // <---  AQUI !
   {
    return base.nombre + " es estudiante";
   }

 }

Polimorfismo por Abstracción:  Cuando hablamos en este caso de abtraccion estamos haciendo referencia a las Clases Abstractas, estas clases tienen una caracteristica muy especial,  NO SE PUEDEN INSTANCIAR, esto quiere decir que no podemos crear un Objeto (en criollo, hacer un «new») de una clase abstracta.

Polimorfismo por Abstraccion:

abstract class Persona
{
 protected string nombre;

  public Persona(string Nombre)
  {
   nombre = Nombre;
  }  

  public abstract string Actividad();  //  <-- AQUI

}

---

class Estudiante:Persona
 {

 public Estudiante(string nombre): base(nombre)
 { }

 public override string Actividad()   // <-- AQUI
 {
   return base.nombre + " es estudiante";
 }

}

Como vemos en el ejemplo anterior tanto en la clase Estudiante que hereda de Persona, como en la clase Persona, existen un método en común llamado «Actividad». El mismo en la clase derivada Estudiante sobrescribe el método abstracto con el mismo nombre (notese que el método no contiene nada en su interior) de la clase Persona.

Polimorfismo por Interface: Las interfaces permiten utilizar metodos comunes a varias clases que no necesariamente tengan que heredar de clases superiores, esto quiere decir que permiten representar metodos de las clases que no tienen ningun tipo de relacion entre ellos. Suena algo confuso, veamos mejor un ejemplo.

Polimorfismo por Interface:

Clase Persona:

abstract class Persona  //hacemos una clase abstracta (no instanciaremos personas)
 {

 protected string nombre;

 public Persona(string Nombre)
 {
   nombre = Nombre;
 }

}

Clase Estudiante:

class Estudiante:Persona,IEtiqueta
 {

  public Estudiante(string nombre): base(nombre)
  { }

  public string Es()
  {
    return this.nombre+" es estudiante";
  }

  public string QueHace()
  {
    return ", estudia";
  }

}

Clase Profesor:

class Profesor:Persona,IEtiqueta
 {

  public Profesor(string nombre): base(nombre)
  { }

  public string Es()
  {
   return nombre+" es profesor";
  }

  public string QueHace()
  {
   return ", enseña";
  }

}

Clase IEtiqueta:

 interface IEtiqueta
 {
   string Es();
   string QueHace();
 }

Ahora bien, como vemos arriba hemos armado una serie de Clases, tenemos la clase Alumno y Profesor que heredan de Persona y a su vez de la interfaz «IEtiqueta» la cual como TODA interfaz lleva solamente la «firma de los metodos», como vemos en el ejemplo, los métodos «Es» y «QueHace» no llevan nada en su interior

Ahora bien, nos preguntaremos ¿ para que queremos la interfaces IEtiqueta ? ¿De que nos sirve si solo lleva la firma de los métodos?

Veamos un pequeño ejemplo:

 ArrayList aula = new ArrayList();

 Estudiante estudiante1 = new Estudiante("chilindrina");
 Estudiante estudiante2 = new Estudiante("Chavo");
 Estudiante estudiante3 = new Estudiante("Quico");

 Profesor profesor1 = new Profesor("Jirafales");

 aula.Add(estudiante1);
 aula.Add(estudiante2);
 aula.Add(estudiante3);

 aula.Add(profesor1);

Como podemos observar hemos creado una pequeña Aula virtual, en la cual hemos introducido 3 estudiantes (Chilindrina, Chavo, Quico) y 1 profesor (Jirafales).

Ahora bien imaginemos que tenemos que recorrer el Aula, para recorrerlo como no es un genérico , tendríamos que «castear» consultando a cada uno de los objetos (Profesor o Alumno) que hemos introducidos  para poder «interrogarlos» .

Pero como podemos ver en el ejemplo, al momento de hacer un Foreach, recorremos el «Aula» pero mediante el tipo «IEtiqueta», osea recorreremos los objetos pero mediante la Interfaz

foreach (IEtiqueta alguien in aula)
 {
  listBox1.Items.Add(alguien.Es() + alguien.QueHace());
 }

Obteniendo una respuesta similar a la siguiente:

Advertencia: Este post puede contener errores en lo general. Por un tiempo estará en estado de revisión.

¡ Espero les haya sido de ayuda !