Polimorfismo

La palabra polimorfismo significa “múltiples formas”, por lo tanto, podríamos definir en el ámbito de
programación que el polimorfismo es “la capacidad de poder enviar un mismo mensaje a objetos
totalmente diferentes, y que cada uno de estos objetos responda de manera diferente”.

Pongamos por ejemplo las clases hombre, vaca y perro, si a todos les damos la orden Come, cada
uno de ellos sabe cómo hacerlo y realizará este comportamiento a su modo.

Veamos otro ejemplo. Tomemos las clases barco, avión y coche, todas ellas derivadas de la clase
padre vehículo; si les enviamos el mensaje Desplázate, cada una de ellas sabe cómo hacerlo.

Realmente, y para ser exactos, los mensaje no se envían a las clases, sino a todos o algunos de los
objetos instanciados de las clases.

En programación tradicional, debemos crear un nombre distinto para la acción de pintarse, si se trata
de un texto o de un marco; en OOP el mismo nombre nos sirve para todas las clases creadas si así lo
queremos, lo que suele ser habitual. El mismo nombre suele usarse para realizar acciones similares
en clases diferentes.

Si enviamos el mensaje Imprímete a objetos de distintas clases, cada uno se imprimirá como le
corresponda, ya que todos saben cómo hacerlo.

El polimorfismo nos facilita el trabajo, ya que gracias a él, el número de nombres de métodos que
tenemos que recordar disminuye considerablemente.

La mayor ventaja la obtendremos en métodos con igual nombre aplicados a las clases que se
encuentran próximas a la raíz del árbol de clases, ya que estos métodos afectarán a todas las clases
que de ellas se deriven.

A continuación se muestra un ejemplo en el que se define una clase polígono; se crean dos clases
derivadas rectángulo y triangulo. Para cada clase derivada se define un método área () y perímetro
con las cuales se aprecia el polimorfismo.

L2 L3
alt

bas

1
class Poligono
{
protected double bas;
protected double alt;

public double P_bas

{
set { bas = value; }
get { return (bas); }
}
public double P_alt
{
set { alt = value; }
get { return (alt); }
}
public virtual double area()
{
return 0;
}
public virtual double perimetro()
{
return 0;
}
}

class Triangulo:Poligono
{
private double L2;
private double L3;

public double P_L2

{
set { L2 = value; }
get { return (L2); }
}
public double P_L3
{
set { L3 = value; }
get { return (L3); }
}
public override double area()
{
double a;
a = (bas * alt) / 2;
return a;
}

2
 public override double perimetro()
{
double a;
a = bas + L2 + L3;
return (a);
}
}

class Rectangulo:Poligono
{
public override double area()
{
double a;
a = bas * alt;
return a;
}
public override double perimetro()
{
double a;
a = (2 * bas) + (2 * alt);
return (a);
}
}

static void Main(string[] args)

{
double bas, alt;

Triangulo Tr = new Triangulo();

Console.WriteLine("Capture base del Polígono: ");

Tr.P_bas = Convert.ToDouble(Console.ReadLine());
bas = Tr.P_bas;

Console.WriteLine("Capture altura del Polígono: ");

Tr.P_alt = Convert.ToDouble(Console.ReadLine());
alt = Tr.P_alt;

Console.WriteLine("Capture Lado2 del Triángulo : ");

Tr.P_L2 = Convert.ToDouble(Console.ReadLine());

Console.WriteLine("Capture Lado3 del Triángulo : ");

Tr.P_L3 = Convert.ToDouble(Console.ReadLine());

3
Console.WriteLine("Área triángulo = {0}", Tr.area().ToString());
Console.WriteLine("Perímetro triángulo = {0}", Tr.perimetro().ToString());

Rectangulo Rec = new Rectangulo();//Se inicializan

atributos de la clase Polígono

Rec.P_bas = bas;
Rec.P_alt = alt;

Console.WriteLine("Área rectángulo = {0}", Rec.area().ToString());

Console.WriteLine("Perímetro rectángulo = {0}", Rec.perimetro().ToString());

Console.ReadKey();
}