Es una parte importante de la programacion orientada a objetos, consiste en que podemos llamar o utilizar las clases hijas o heredadas de la misma forma como lo hacemos con la clase padre.
Entonces, podemos tener una clase base o padre llamada Producto, y clases hijas o heredadas, como por ejemplo, detergente, alimento, jabon, esta clase tiene un método que se llama uso, este método se implementa de manera diferente en cada clase hija o heredada.
Es importante tener presente un sistema de tipos en polimorfismo, el sistema de tipos no es mas que las clases que creemos en nuestro sistema.
A continuación tenemos una clase Producto que es abstract, o sea debe ser heredada, no puede ser instanciada; con varias propiedades y un método Uso, el método Uso se implementara en cada clase Hija dependiendo de la clase.
Las clases derivadas o hijas, en este caso, Detergente, Jabon y Arroz tienen que implementar el método Uso de manera diferente, pues para cada uno por ejemplo el arroz se usa para cocinarlo y comerlo, mientras que el jabon se utiliza para usarlo con agua y lavarnos las manos, el detergente se utiliza para con el agua lavar la ropa, etc.
Sin embargo aqui lo que es importante es que todas las clases Detergente, Jabon y Arroz son un Producto, y esta es la esencia del Polimorfismo.
Ahora veamos el código de las clases, la clase base o padre, o sea, la clase Producto se vera así:
|
namespace WpfPolimorfismo.Model
{
public abstract class Producto
{
public int Id
{
get;
set;
}
public string NombreProducto
{
get;
set;
}
public string CodigoBarras
{
get;
set;
}
public UnidadMedida IdUnidad
{
get;
set;
}
public abstract void
Uso(Producto producto);
}
}
|
Ahora la clase Unidad de Medida que es una clase base, que hace parte de los tipos de datos de la clase padre Producto:
|
namespace WpfPolimorfismo.Model
{
public class UnidadMedida
{
public int Id
{
get;
set;
}
public string Unidad
{
get;
set;
}
}
}
|
Ahora la clase Jabon, veamos como es su código:
|
namespace WpfPolimorfismo.Model
{
public class Jabon : Producto
{
public override void
Uso(Producto producto)
{
// Se humedece con agua y se unta en la manos
// para limpieza de las mismas o del cuerpo en general.
}
}
}
|
Vemos que la clase Jabon solo contiene el método Uso, y que este método es override, esto indica que sobre escribe el método de la clase base o padre. Observamos que el comportamiento de este método es especifico para esta clase.
Ahora veamos la clase Detergente:
|
namespace WpfPolimorfismo.Model
{
public class Detergente : Producto
{
public override void
Uso(Producto producto)
{
// Se utiliza para lavar la ropa, se adiciona
// una parte al agua en la lavadora o en una tina
}
}
}
|
Observamos que la implementación del método Uso es diferente al de la clase Jabon.
Ahora veamos el código para la clase Arroz:
|
namespace WpfPolimorfismo.Model
{
public class Arroz : Producto
{
public override void
Uso(Producto producto)
{
// Se lava con agua, se prepara en agua con
// sal y aceite y se come caliente.
}
}
}
|
Como vemos esto aplicado a nuestro desarrollo, en el caso de la plataforma WPF, que es la que utilizamos para nuestro desarrollo de aplicaciones de escritorio para Windows, existe un tipo de dato Control, de este tipo heredan varios controles que utilizamos como por ejemplo los Button y los TextBox.
Para probar el Polimorfismo entonces en la pantalla MainWindow.xaml creamos los siguientes controles:
|
<Window x:Class="WpfPolimorfismo.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:local="clr-namespace:WpfPolimorfismo"
mc:Ignorable="d"
Title="MainWindow" Height="450" Width="800">
<Grid>
<Button x:Name="BtnUno" Content="Button" HorizontalAlignment="Left" Margin="415,38,0,0" VerticalAlignment="Top" Width="75"/>
<TextBlock x:Name="TblUno" HorizontalAlignment="Left" Margin="34,38,0,0" TextWrapping="Wrap" Text="TextBlock" VerticalAlignment="Top"/>
<TextBox x:Name="TBuno" HorizontalAlignment="Left" Height="23" Margin="121,35,0,0" TextWrapping="Wrap" Text="TextBox" VerticalAlignment="Top" Width="249"/>
</Grid>
</Window>
|
Esto se vera de la siguiente manera:
A estos controles les agregamos un nombre y en el Code Behind del formulario, utilizaremos Polimorfismo para colocarlos en una lista genérica. El código es el siguiente:
|
namespace WpfPolimorfismo
{
///
/// Interaction logic for
MainWindow.xaml
///
|
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
List controles = new List();
controles.Add(BtnUno);
controles.Add(TBuno);
}
}
}
Como podemos observar creamos una lista genérica del tipo Control, y luego le asignamos a la lista el control BtnUno que es un Button y posteriormente le asignamos a la misma lista de tipo Control un objeto TBuno de tipo TextBox.
Aqui apreciamos que uno es un botón y otro es una caja de texto pero ambos heredan de Control y pueden ser tratados como tal.
Entonces el polimorfismo nos permite tratar diferentes clases derivadas o hijas como si fueran del mismo tipo, pues heredan del padre, o sea polimorfismo se da o se aplica cuando una clase hija puede ser llamada o almacenada como su clase padre.
Hasta la próxima!
