jueves, octubre 18, 2018

Programacion Orienada a Objetos. Polimorfismo

Polimorfismo

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);

    }
}
Observamos que el método Uso esta tambien declarado como abstract, esto lo que permite es que lo implementemos en cada clase hija, pues en cada clase hija se ejecuta de diferente manera este método. 

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!







sábado, septiembre 15, 2018

Como recorrer y ordenar un Array en Diagramas de Flujo

En esta nueva entrada vamos a aprender y resolver nuevos retos de programacion a través de los diagramas de flujo.

Iniciemos con uno sencillo, calcular el cuadrado de un numero:


1. Leemos un numero
2. Creamos una nueva caja de operaciones y en ella definimos una variable cuadrado, y le asignamos el valor de la multiplicación del numero por el mismo para calcular el cuadrado.
3. Imprimimos el valor del cuadrado
4. Capturamos si desea continuar
5. Preguntamos si la respuesta es S, si es S, lo enviamos a que capture un nuevo numero y vuelva a calcular el resultado.
6. Si es no, entonces terminamos.


Utilización de Bucles para ordenar

Un bucle es un grupo de instrucciones que se repiten un numero determinado de veces, el mas representativo de los bucles es la instrucción for, pero existen tambien while y do while.

El enunciado del reto es: Captura 50 números, ordénelos y muestre los 5 números mayores y los 5 menores.



1. Definimos una Array de una longitud de 50 elementos, para esto definimos una caja de operaciones, el array lo llamamos Numeros
2. Creamos un ciclo for, o un bucle for, en donde creamos una variable i que inicia en cero, valida que sea menor a 50 y se incremente de 1 en 1. 
3. Hacemos la captura del numero y lo almacenamos en N.
4. Almacenamos el numero capturado en el Array Numeros en la posición i, que es la que tenga el Bucle.
5. Cuando finaliza el ciclo, esto es en el conector A, debemos ordenar el array, para ello creamos un nuevo bucle for.
6. En este declaramos una variable TMP en la cual almacenamos el valor del array en la posición en valla la variable i
7. creamos una variable TPOS que inicializamos en cero (0).
8. Creamos un segundo bucle for, que inicia en el valor de i mas 1
9. Preguntamos si el valor de TMP es mayor que Numeros en la posición j
10. Si dice que No, en TMP almacenamos el valor del array en la posición j, y en TPOS, almacenamos el valor de j.
11. Continuamos el bucle.
12.Si la respuesta es SI a la pregunta TMP es mayor que Numeros en la posición j, entonces continuamos con la siguiente posición o iteración del ciclo.
13. Cuando termine el ciclo, preguntamos si TPOS es igual a cero (0).
14. Si, es SI, entonces lo enviamos que continúe el bucle for a la siguiente iteración.
15. Si es NO, entonces TMP lo hacemos igual a Numeros en la posición i
16. Numeros en la posición i lo hacemos igual a Numeros en la posición TPOS
17. Numeros en la posición TPOS lo hacemos igual al contenido de TMP
18. Lego en el conecto B de la imagen, termina el segundo bucle.
19. luego imprimimos los 5 números mayores del array.
20. Imprimimos los 5 números menores .
21. Finalizamos.


Calcular la Edad de una Factura

Ahora vamos a calcular la edad de una Factura, para esto, capturamos el numero de la factura, el cliente y la fecha de la factura.


Para esto, seguimos los siguientes pasos
1. Definimos un Array que llamamos Meses de 12 posiciones de longitud o tamaño.
2. Llenamos el array con los valores de los números de los dias en cada mes del año.
3. capturamos o pedimos los datos de la factura.
4, creamos una caja de operaciones, en la cual definimos una variable FechaActual, en la cual realizamos la operación de multiplicar el año por 365 y le sumamos el dia de la fecha.
5. Creamos una variable que llamamos AcumDiaMes y lo hacemos igual a cero.
6. Creamos un bucle for, aqui en AcumDiaMes acumulamos los dias de los meses, este bucle ira desde cero hasta el valor del mes actual.
7. En el operador A, realizamos los mismos pasos pero para la fecha de la factura
8. creamos una caja de texto después del bucle, en la cual calculamos la edad de la factura en una variable que llamamos EdadFactura, luego imprimimos el resultado.
9. Fin.

Calcular si un año es bisiesto o no

Para esto diseñamos el siguiente diagrama de flujo



1. Capturamos los datos, "Digite el año" 
2. creamos una variable que llamamos Bisiesto y la igualamos a cero.
3. en esta variable Bisiesto, calculamos el modulo o Mod de la división del año entre 4, Bisiesto = Anio MOD 4
4. Preguntamos  si bisiesto es mayor a 0
5. Si es cierto, entonces imprimimos el año no es bisiesto.
6. Si es falso, entonces mostramos un mensaje indicando que el año es bisiesto.
7. Finalizamos.


Crear una Vista desde Cero, ASP.NET MVC

En algunas ocasiones necesitamos crear una vista que no esta ligada a un modelo, como  hemos estado realizando en talleres anteriores.

Una de las cosas a recordar que Microsoft utiliza de manera por defecto Razor, que básicamente lo que significa es que podemos utilizar el lenguaje C# o VB.NET como lenguaje de cliente, recuerden que por defecto el lenguaje de cliente para paginas web HTML es JavaScript.

No es el único motor para trabajar en nuestra vistas, existen otros por ejemplo: Spark, NHaml, Brail, StringTemplate o NVelocity,

Para trabajar con razor en nuestras vistas debemos utiliza el arroba como carácter de inicio de código, esto indica que lo que sigue es código C# y será interpretado como tal.

@{  var miVariable= 5; }

Si queremos realizar una pregunta lo haremos de la siguiente manera:

@if(miVariable >= 5)
{
     El valor es: @miVariable

}
else
{
     El valor no es valido!
}

Es importante indicar que el código Razor llega hasta la llave que cierra.


Podemos crear secciones de código Razor como el siguiente:

   

            @foreach (var i = 1; i < 32; i++ )
            {
               
  • El dia es @i

  •         }
       

Aqui Creara los ítems de una lista no ordenada con los números del 1 al 31. Una de las cosas a entender es que Razor nos permite incluir lógica en la vista con código HTML como en este ejemplo.
Para crear una vista necesitamos de un Controlador, al controlador le colocamos o creamos nuestra acción. 

Vamos a crear una acción en el controlador, esta acción la llamaremos NuevaVista, en esta acción vamos a crear unas variable de tipo anónimo, con esto no creamos la clase como tal, luego adicionamos esto a una colección genérica con lo cual pasaremos los datos a la vista desde el controlador a través del objeto ViewBag.

Vamos a crear una clase de que llamaremos Mes en el mismo controlador, la clase se vera de la siguiente manera:

    public class Mes
    {
        public int Id { get; set; }

        public string NombreMes { get; set; }
    }

Entonces, en nuestro controlador crearemos una nueva acción que quedara así:

        public ActionResult NuevaVista()
        {
            ViewBag.ListaMeses = new List() {
            new Mes { Id = 1, NombreMes = "Enero" },
            new Mes { Id = 2, NombreMes = "Febrero" },
            new Mes { Id = 3, NombreMes = "Marzo" },
            new Mes { Id = 4, NombreMes = "Abril" },
            new Mes { Id = 5, NombreMes = "Mayo"  },
            new Mes { Id = 6, NombreMes = "Junio" },
            new Mes { Id = 7, NombreMes = "Julio" },
            new Mes { Id = 8, NombreMes = "Agosto" },
            new Mes { Id = 9, NombreMes = "Septiembre" },
            new Mes { Id = 10, NombreMes = "Octubre" },
            new Mes { Id = 11, NombreMes = "Noviembre" },
            new Mes { Id = 12, NombreMes = "Diciembre" },
        };

            return View();
        }



Ahora vamos a crear la nueva vista.



Esto lo hacemos dando clic derecho sobre el nombre de la acción en el controlador, en el menú que nos aparece seleccionamos Add View, o Adicionar vista, esto nos mostrara la ventana de creación de las vistas:


Como se aprecia el nombre de la vista lo crea de acuerdo al nombre que se le haya colocado, el template de la vista es Empty o vacio, pero se puede seleccionar un template de los que ya conocemos que se generan de manera automática a un modelo.

Aqui es dar clic en el botón Add, y crear la vista.



Esta es la vista que se crea, ahora vamos a configurarla para que se pueda ver como deseamos.

Modificamos la vista para que se vea de la siguiente manera:


@{
    ViewBag.Title = "NuevaVista";
}

Nueva Vista





   

       

           
       

       

            @Html.DropDownList("ListaMeses",
                    (SelectList)ViewBag.ListaMeses, 
                    new { @class = "from-control" });
       

       

   

Creamos un div con un style y le agregamos un alto a la vista de 360 pixeles, luego creamos un div con una clase de tipo row de bootstrap, lo mas importante es que utilizamos uno de los helpers de HTML y el control DropDownList que le pasamos los parametrs del nombre, que es el mismo del ViewBag, el segundo parámetro es el Viewbag con una conversión a un SelectList que nos permitirá mostrar la lista de datos.

Al ejecutar la vista veremos lo siguiente:

Ahora si desplegamos la lista, o sea el DropDownList, se vera asi:



De esta manera podremos crear desde cero nuestras vistas, o utilizar la plantilla que ya tiene Asp.net MVC.

Que lo disfruten!

Hasta la próxima.