jueves, 4 de septiembre de 2014

9.- Los métodos

Como dijimos, los métodos son las acciones realizadas por el objeto. En la cuarta entrega, escribíamos con el “lenguaje der Waki” la clase Vehículo con los métodos Avanzar, Arrancar o Parar. En el método Avanzar le añadíamos la velocidad hasta la que queríamos que nuestro vehículo llegara.
El valor velocidad es el parámetro del método, es el que aparece en el método, mientras que el argumento es el valor pasado una vez creado el objeto. Ejemplo.
C#
/* ************************************************
* © WAKI 2014
* PROYECTO:        Aprender a Programar.
* Archivo:         Program.cs
* Descripción:     Clase Main y Vehículo              
* Historial:           
* Comentarios:
*
****************************************************/
using System;
namespace MyNameSpace
{
    class MyApp
    {
        static void Main(string[] args)
        {
            Console.WriteLine ("Comienza la App ==>");
            Vehiculo miVehiculo = new Vehiculo();

            miVehiculo.Avanzar(50); // esto hace avanzar el vehículo hasta los 50km/h. 50 es el ARGUMENTO
            Console.WriteLine ("Pulse una tecla para frenar el vehículo...");
            Console.ReadLine();

            miVehiculo.Avanzar(0); // esto hace parar. 0 es el ARGUMENTO
            Console.WriteLine("Pulse INTRO para finalizar..");
            Console.ReadLine();
       }
    }

    class Vehiculo
    {
        public Vehiculo()
        {
            // código utilizado al instanciar la clase
        }

        public void Avanzar(int kmHora)
        {
            // kmHora es el parámetro tipo número entero del método Avanzar
            Console.WriteLine("La velocidad del vehículo es de " + kmHora.ToString() + " km/h");
        }
    }
}

VB.NET
' ************************************************
'* © WAKI 2014
'* PROYECTO:        Aprender a Programar.
'* Archivo:         Program.cs
'* Descripción:     Clase Main y Vehículo             
'* Historial:           
'* Comentarios:
'*
'***************************************************

Namespace MyNameSpace
    Class MyApp
        Private Shared Sub Main(args As String())
            Console.WriteLine("Comienza la App ==>")
            Dim miVehiculo As New Vehiculo()

            miVehiculo.Avanzar(50)
            ' esto hace avanzar el vehículo hasta los 50km/h. 50 es el ARGUMENTO
            Console.WriteLine("Pulse una tecla para frenar el vehículo...")
            Console.ReadLine()

            miVehiculo.Avanzar(0)
            ' esto hace parar. 0 es el ARGUMENTO
            Console.WriteLine("Pulse INTRO para finalizar..")
            Console.ReadLine()
        End Sub
    End Class

    Class Vehiculo
        ' código utilizado al instanciar la clase
        Public Sub New()
        End Sub

        Public Sub Avanzar(kmHora As Integer)
            ' kmHora es el parámetro tipo número entero del método Avanzar
            Console.WriteLine("La velocidad del vehículo es de " & kmHora.ToString() & " km/h")
        End Sub
    End Class
End Namespace

Analizando código…
  1. Escribimos en  la consola “Comienza App ==>”
  2. Creamos el objeto miVehiculo
  3. Llamamos al método Avanzar de miVehículo pasando el argumento 50
  4. Se visualiza en la consola “La velocidad del vehículo es de 50 Km/h”
  5. Escribimos en la consola “Pulse una tecla para frenar el vehículo...”
  6. Al pulsar INTRO, llamamos de nuevo al método Avanzar de miVehículo pasando el argumento 0
  7. Se visualiza en la consola “La velocidad del vehículo es de 0 Km/h”
  8. Al pulsar INTRO finalizamos.
Nota: Solo hay detalle nuevo que se nos pasa por alto y es que en C# ¿se suman las palabras?. El texto se concatena en C# mediante el signo + mientras que en VB.NET es mediante el signo &. Estos son operadores y los hay a miles (no tantos Waki!).
Un método puede contener  múltiples parámetros y de cualquier índole. Podría crear una clase a la que pasará como un argumento un objeto tipo Vehículo, cualquier objeto admite, ahora si, si la clase o el método tiene como parámetros un objetos tipo Vehículo, solo y exclusivamente podemos pasarle este tipo de objeto y no un número del tipo int, Integer o entero, un string o cadena, boolean o booleano, etc.
Más cosas con los métodos, podemos crear métodos con el mismo nombre pero con distinto tipo de parámetros.  Esto se llama sobrecarga y permite utilizar un mismo método de diferente forma como en la vida misma o ¿nosotros caminamos siempre del mismo modo?,  a pesar de que el método caminar es el mismo, podemos hacerlo calzados o descalzados (con lo que variaría la velocidad), el tipo de calzado, hacia atrás, hacia adelante, etc. Expongo un ejemplo.
C#
public void Avanzar(int kmHora)
{
      // kmHora es el parámetro tipo número entero del método Avanzar
      Console.WriteLine("La velocidad del vehículo es de " +          KmHora.ToString() + " km/h");
}

public void Avanzar()
{
     // avanza hasta los 50 Km/h como valor predeterminado
     Console.WriteLine("La velocidad del vehículo es de 50 km/h");
}

public void Avanzar(int kmHora, bool limitarA120)
{
       // kmHora es el parámetro tipo número entero del método Avanzar
// limitarA120 no permite que pase de 120 km/h
if (limitarA120 && kmHora > 120)
{
kmHora = 120;
}
       Console.WriteLine("La velocidad del vehículo es de " + kmHora.ToString() + " km/h");
}

 VB.NET
Public Sub Avanzar(kmHora As Integer)
    ' kmHora es el parámetro tipo número entero del método Avanzar
    Console.WriteLine("La velocidad del vehículo es de " & kmHora.ToString() & " km/h")
End Sub

Public Sub Avanzar()
    ' avanza hasta los 50 Km/h como valor predeterminado
    Console.WriteLine("La velocidad del vehículo es de 50 km/h")
End Sub

Public Sub Avanzar(kmHora As Integer, limitarA120 As Boolean)
    ' kmHora es el parámetro tipo número entero del método Avanzar
    ' limitarA120 no permite que pase de 120 km/h
    If limitarA120 AndAlso kmHora > 120 Then
        kmHora = 120
    End If

    Console.WriteLine("La velocidad del vehículo es de " & kmHora.ToString() & " km/h")
End Sub

Tres métodos Avanzar pero con distintos parámetros. El primero permite llevar al vehículo a una velocidad concreta, el segundo lleva al vehículo a una velocidad predeterminada y el tercero lleva un parámetros que nos va a permitir limitar la velocidad a 120 Km/h.  Si el segundo argumento pasado  (parámetro limitarA120), tiene un valor false, (falso), se comporta como el método primero, pero si el argumento pasado tiene un valor true, (verdadero), el método limitará la velocidad a 120. ¿Cómo?  Mediante el fragmento if o If…

La instrucción if para C# o If…Then para VB.NET tiene muchas variantes, pero esta es la más sencilla. Lo primero que hace es efectuar una comparación booleana, quiere decir que se obtendrá un Sí o un No, un Verdadero o un Falso, un true o un false. Dentro de esta condición hacemos otra comparación mediante el operador && o AndAlso que es el operador equivalente a decir Y; en el método preguntamos, ¿es verdadero el argumento pasado  limitarA120? Y además ¿es verdadero que el argumento pasado de velocidad es mayor que 120? Pues si esto es verdadero, se limitará la velocidad a 120 Km/h, pero si alguno de las condiciones de la instrucción if no se cumple, el argumento limitar es falso o la velocidad es inferior a 120, pues no se limitará. ¿OK? Pues tan útil como ya he dicho se llama sobrecarga de métodos.

Por último, los métodos también pueden devolver valores. Si le pedimos a una calculadora que sume dos número, primero nos solicitará los dos números y luego el método suma, devolverá un resultado con las dos cantidades sumadas, bien, pues a un método por ejemplo le pasamos dos argumentos y este, devuelve la suma de ambos. En VB.NET los métodos que devuelven valores se llaman funciones. Ejemplos es lo que nos hace falta!. Vamos a convertir los tres métodos del ejemplo anterior pero devolviendo el texto que escribimos en la consola, evitando incluir Console.WriteLine en cada método.

C#
/* ************************************************
* © WAKI 2014
* PROYECTO:        Aprender a Programar.
* Archivo:         Program.cs
* Descripción:     Clase Main y Vehículo         
* Historial:         
* Comentarios:
*
****************************************************/

using System; 
namespace MyNameSpace
{
    class MyApp
    {
        static void Main(string[] args)
        {
            Console.WriteLine ("Comienza la App");
            Vehiculo miVehiculo = new Vehiculo();
 
            string textoDeSalida = miVehiculo.Avanzar(90); // esto hace avanzar el vehículo hasta los 90km/h. 90 es el ARGUMENTO
            Console.WriteLine(textoDeSalida);   // Aquí se imprime el texto devuelto por los métodos
            Console.WriteLine ("Pulse una tecla para frenar el vehículo...");
            Console.ReadLine();
            textoDeSalida = miVehiculo.Avanzar(0); // esto hace parar. 0 es el ARGUMENTO
            Console.WriteLine(textoDeSalida);   // Aquí se imprime el texto devuelto por los métodos
            Console.WriteLine("Pulse una tecla para activar velocidad predeterminada...");
            Console.ReadLine();
            textoDeSalida = miVehiculo.Avanzar(); // esto hace parar. 0 es el ARGUMENTO
            Console.WriteLine(textoDeSalida);   // Aquí se imprime el texto devuelto por los métodos
            Console.WriteLine("Pulse una tecla para limitar velocidad...");
            Console.ReadLine();
            textoDeSalida = miVehiculo.Avanzar(150,true); // velocidad a 150 km/h y limitador activado
            Console.WriteLine(textoDeSalida);   // Aquí se imprime el texto devuelto por los métodos
            Console.WriteLine("Pulse INTRO para finalizar..");
            Console.ReadLine();
        }
    }
 
    class Vehiculo
    {
        public Vehiculo()
        {
            // código utilizado al instanciar la clase
        }

        public string Avanzar(int kmHora)
        {
            // kmHora es el parámetro tipo número entero del método Avanzar
            return "La velocidad del vehículo es de " + kmHora.ToString() + " km/h";
        } 

        public string Avanzar()
        {
            // avanza hasta los 50 Km/h como valor predeterminado
            return "La velocidad del vehículo es de 50 km/h";
        } 

        public string Avanzar(int kmHora, bool limitarA120)
        {
            // kmHora es el parámetro tipo número entero del método Avanzar
            // limitarA120 no permite que pase de 120 km/h 
            string textoDeSalida = "La velocidad del vehículo es de "; 

            if (limitarA120 && kmHora > 120)
            {
                textoDeSalida = "La velocidad del vehículo era de " + kmHora + " Km/h, pero ahora es de ";
                kmHora = 120;
            }
            return  textoDeSalida + kmHora.ToString() + " km/h";
        }
    }
}

VB.NET 

/* ************************************************
* © WAKI 2014
* PROYECTO:        Aprender a Programar.
* Archivo:         Program.cs
* Descripción:     Clase Main y Vehículo
* Historial:           
* Comentarios:
*
****************************************************/
using System;
namespace MyNameSpace
{
    class MyApp
    {
        static void Main(string[] args)
        {
            Console.WriteLine ("Comienza la App");
            Vehiculo miVehiculo = new Vehiculo();
 
            string textoDeSalida = miVehiculo.Avanzar(90); // esto hace avanzar el vehículo hasta los 90km/h. 90 es el ARGUMENTO
            Console.WriteLine(textoDeSalida);   // Aquí se imprime el texto devuelto por los métodos
            Console.WriteLine ("Pulse una tecla para frenar el vehículo...");
            Console.ReadLine();
            textoDeSalida = miVehiculo.Avanzar(0); // esto hace parar. 0 es el ARGUMENTO
            Console.WriteLine(textoDeSalida);   // Aquí se imprime el texto devuelto por los métodos
            Console.WriteLine("Pulse una tecla para activar velocidad predeterminada...");
            Console.ReadLine();
            textoDeSalida = miVehiculo.Avanzar(); // esto hace parar. 0 es el ARGUMENTO
            Console.WriteLine(textoDeSalida);   // Aquí se imprime el texto devuelto por los métodos
            Console.WriteLine("Pulse una tecla para limitar velocidad...");
            Console.ReadLine();
            textoDeSalida = miVehiculo.Avanzar(150,true); // velocidad a 150 km/h y limitador activado
            Console.WriteLine(textoDeSalida);   // Aquí se imprime el texto devuelto por los métodos
            Console.WriteLine("Pulse INTRO para finalizar..");
            Console.ReadLine();
        }
    }

    class Vehiculo
    {
        public Vehiculo()
        {
            // código utilizado al instanciar la clase
        }

        public string Avanzar(int kmHora)
        {
            // kmHora es el parámetro tipo número entero del método Avanzar
            return "La velocidad del vehículo es de " + kmHora.ToString() + " km/h";
        }

        public string Avanzar()
        {
            // avanza hasta los 50 Km/h como valor predeterminado
            return "La velocidad del vehículo es de 50 km/h";
        } 

        public string Avanzar(int kmHora, bool limitarA120)
        {
            // kmHora es el parámetro tipo número entero del método Avanzar
            // limitarA120 no permite que pase de 120 km/h 

            string textoDeSalida = "La velocidad del vehículo es de ";

            if (limitarA120 && kmHora > 120)
            {
                textoDeSalida = "La velocidad del vehículo era de " + kmHora + " Km/h, pero ahora es de ";
                kmHora = 120;
            }
            return  textoDeSalida + kmHora.ToString() + " km/h";
        }
    }
}

Analizando código… en el método Main, ocurre lo siguiente:
  1. Escribimos en  la consola “Comienza App ==>”
  2. Creamos el objeto miVehiculo
  3. Llamamos al método Avanzar(90) de miVehículo pasando el argumento 90
  4. Se visualiza en la consola “La velocidad del vehículo es de 90 Km/h”
  5. Escribimos en la consola “Pulse una tecla para frenar el vehículo...”
  6. Al pulsar INTRO, llamamos de nuevo al método Avanzar(0) de miVehículo pasando el argumento 0
  7. Se visualiza en la consola “La velocidad del vehículo es de 0 Km/h”
  8. Escribimos en la consola “Pulse una tecla para activar velocidad predeterminada...”
  9. Al pulsar INTRO, llamamos de nuevo al método Avanzar() sin argumentos de miVehiculo.
  10. Se visualiza en la consola “La velocidad del vehículo es de 50 Km/h”
  11. Escribimos en la consola “Pulse una tecla para limitar velocidad...”
  12. Al pulsar INTRO, llamamos de nuevo al método Avanzar(150) de miVehículo pasando el argumento 150
  13. Se visualiza en la consola “La velocidad del vehículo era de 150 Km/h, pero ahora es de 120 Km/h.”
  14. Al pulsar INTRO finalizamos.
En el último método Avanzar creamos una variable textoDeSalida, a la cual le damos un valor u otro dependiendo si se limita la velocidad o no y para devolver los valores al lugar desde los hemos llamado es mediante la instrucción return que retorna o devuelve el valor calculado.
Para la sobrecarga de métodos, lo único que no podemos hacer es crear dos métodos con el mismo número de parámetros y del mismo tipo, lo que provocaría una ambigüedad y el compilador no sabría cual ejecutar.
Como ya sabemos compilar, practica y crea, que no duele!
Saludos “der Waki”
Publicado por en

No hay comentarios:

Publicar un comentario

Suscribirse a: Enviar comentarios (Atom)