Java / Metodos

Bienvenidos sean a este post, hoy hablaremos sobre metodos.

Los metodos, tambien conocidos como funciones, son una accion determinada por distintos tipos de instrucciones. Los metodos estan almacenados en las clases y estos nos permitiran ejecutar una accion X, p.e. println es un metodo que nos pemite mostrar textos en una consola. main tambien es un metodo y es el encargado de ejecutar nuestro programa, como sucede en C, pero no deja de ser un metodo. Si bien hemos visto algunos metodos muy basicos hoy veremos como definir nuestros propios metodos, como es su estructura y otras caracteristicas. Veamos su estructura:

modificador tipoRetorno nombreMetodo ([Lista de parametros])
{
.…. Instrucciones …..
}

Veamos cada una de sus caracteristicas:

• modificador, el tipo de acceso a nuestro metodo (public, private, protected)
• tipoRetorno, el tipo de valor que devolvera (int, long, String, etc)
• nombreMetodo, el nombre que va a identificar a nuestro metodo y deben evitar que coincida con las palabras reservadas
• Lista de parametros, por esta via podremos enviar informacion a nuestro metodo pero es opcional
• Instrucciones, el conjunto de instrucciones para nuestro metodo

El llamar a un metodo puede producir dos resultados, el primero es retornar un valor y el segundo es procesar una informacion y no devolver nada. Podemos llamar directamente al metodo y que ejecute esas instrucciones o si devuelve un valor podemos asignarselo a una variable, veamos primero un ejemplo de llamada normal a un metodo cualquiera:

mifuncion();

Este es un llamado simple que podemos hacer en cualquier parte del cuerpo de main. Ahora veamos como utilizarlo para asignar un valor a una variable:

int total = sumar(6,9);

En esta linea tenemos un metodo que suma los valores enviados al mismo, en este caso sumar, el cual retornara un valor de 15 y se lo asignara a total para poder ser utilizado por el programa. Antes de ver un ejemplo, hablemos sobre una de las caracteristicas mas utilizadas en lenguajes derivadas de C o C++ como es void (y no el Boyyy de God of War).

void es una palabra reservada y usualmente puede ser utilizada como comodin porque nos permite crear un metodo sin necesidad de que devuelva un tipo de dato especifico. Si biien no es una buena practica, tendremos muchas situaciones donde no debemos devolver un resultado sino simplemente procesarlo. En los ejemplo que vimos aca en Java el main es de tipo void pero en C++, el main es de tipo int porque por buena practica se debe retornar un valor de cero para indicar que finaliza correctamente. Para entender un poco mejor el concepto de metodos veamos el primer ejemplo:

ExampleVoid.java

public class ExampleVoid
{

        public static void main(String[] args)
        {
                metodoRankPuntos(255.7);
        }

        public static void metodoRankPuntos(double puntos)
        {
                if (puntos >= 202.5)
                {
                        System.out.println("Rank A1");
                }
                else if (puntos >= 122.4)
                {
                        System.out.println("Rank A2");
                }
                else
                {
                        System.out.println("Rank A3");
                }
        }
}

En este ejemplo, podemos ver como nuestra clase en su cuerpo main unicamente llama a metodoRankPuntos. A este le enviamos un valor, para este caso 255.7, despues tenemos por fuera de main definido al metodo metodoRankPuntos. En este metodo tendremos tres condicionales, el primero evaluara si el valor informado es mayor o igual a 202.5, en caso de ser verdadero mostrara el mensaje Rank A1, en caso contrario chequea si el valor es mayor o igual a 122.4 , en caso de ser verdadero mostrara el mensaje Rank A2, de caso contrario mostrara el mensaje Rank A3, si lo compilamos y ejecutamos obtendremos la siguiente salida:

$ java ExampleVoid
Rank A1
$

Observen como el valor enviado coincidio con el primer condicional, muestra el mensaje en este y sale del programa porque el metodo main no tiene otro metodo o instruccion en su cuerpo y el metodo llamado es lo unico que hace. Pasemos a ver como es el pasaje de valores a los metodos. Como mencionamos antes, los metodos tambien tienen la posibilidad de tener una lista de parametros o atributos. Estos permiten recibir valores para ser procesados por nuestro metodo. Estos pueden ser informados por un valor directo o por una referencia, tambien conocida como variable. Tambien podemos utilizar otro metodo perteneciente a un objeto creado de una clase, veamos un ejemplo de como enviar informacion a un metodo:

swappingExample.java

public class swappingExample
{
        public static void main(String[] args)
        {
                int a = 30;
                int b = 45;
                System.out.println("Antes de cambiarlo, a = "
                                 + a + " y b = " + b);
                funcionSwap(a,b);
                System.out.println(
                        "\n**Ahora antes y despues del cambio los" +
                        " valores seran los mismos**");
                System.out.println("Despues del cambio, a = "
                        + a + " y b = " + b);
        }

        public static void funcionSwap(int a, int b)
        {
                System.out.println(
                        "Antes del cambio(Dentro), a = " + a
                        + " y b = " + b);
                int c = a;
                a = b;
                b = c;
                System.out.println(
                        "Despues del cambio(Dentro), a = " + a
                        + " y b = " + b);
        }
}

Dentro del main tendremos dos variables, a y b, con los valores 30 y 45 respectivamente. Primero mostramos los valores de a y b en pantalla, luego llamaremos al metodo funcionSwap donde enviaremos los valores de a y b, luego mostrara un mensaje y nuevamente los valores de a y b. Hablemos del metodo funcionSwap, este metodo recibira dos valores de tipo int. Lo primero que haremos es mostrar los valores de a y b, luego haremos el intercambio entre a y b, y finalmente mostramos nuevamente los valores. En este caso, tambien tenemos un mensaje para indicar que esto se realizo en el metodo. Con esto comentado, compilemos y ejecutemos para ver la salida:

$ java swappingExample
Antes de cambiarlo, a = 30 y b = 45
Antes del cambio(Dentro), a = 30 y b = 45
Despues del cambio(Dentro), a = 45 y b = 30

**Ahora antes y despues del cambio los valores seran los mismos**
Despues del cambio, a = 30 y b = 45
$

Observen como primero vemos el valor de a y b, luego antes de cambiarlo pero dentro del metodo, luego lo vemos cambiado siempre dentro del metodo y por ultimo volvemos a mostrar los valores de a y b pero del main donde vemos que tienen los valores de antes, pero que paso? no los habiamos cambiado? Si los habiamos cambiado pero dentro del metodo y nosotros al no devolver los valores fuera del mismo el main nunca tuvo ese cambio y por este motivo mantuvo los valores sin cambiarlos. Esto es por el alcance de la informacion, al ser locales del metodo se borraran de memoria cuando finalice el mismo. Y al no modificar las variables externas, seguiran con sus valores previos.

Siguiendo con los metodos, otra opcion que disponemos en los metodos es la sobrecarga. Esto nos permite tener mas de un metodo con el mismo nombre pero con distintos parametros, similar a cuando hablamos en los constructores en este post, y el compilador se encargara de diferenciarlos justamente por medio de ellos (parametros). Esto nos permitiria ejecutar varias acciones con el mismo nombre pero con distintos resultados, por ejemplo si nosotros tuvieramos el siguiente metodo:

public int sumar(int a, int b)
{
return a + b;
}

Pero nosotros necesitamos que se concatenen textos junto a los numeros enteros. Para ello, podriamos agregar un nuevo metodo como este:

public String sumar(String a, String b)
{
return a + b;
}

Estas simple definiciones nos permitira realizar unos llamados al metodo tan simples como los siguientes:

sumar(6,9);
sumar("Hola,"," mundo!!!");

Si los vieramos asi no habria forma de identificar al cual va a llamar pero el compilador si porque verfica el tipo de parametros y lo envia al metodo que corresponda

Nota: 
La sobrecarga se diferencia por los atributos (parametros) no por las instrucciones, recuerden que las instrucciones pueden ser las mismas dentro de los metodos pero no los parametros porque de lo contrario al compilarlo devolvera un error de metodo duplicado.

Antes de finalizar vamos a comentar un poco sobre los modificadores. Mencionamos que tenemos tres: public, private y protected. Estos son basicamente para poder acceder o no a los metodos desde las instancias creadas de la clase. Si usamos public permitira que los metodos sean accesibles desde las instancias y herederas de la clase. En cambio, si usamos private no podran ser accedidas desde las instancias o herederas pero si internamente en la clase. Y protected es algo intermedio, porque si bien restringue el acceso a las instancias pero las herederas si podran acceder.

En resumen, hoy hemos visto los metodos, su estructura, algunas formas de llamarlo, asignarlo a una variable, hemos hablado sobre el void, para que se usa, como enviar informacion a un metodo, hemos visto el concepto de sobrecarga, y hablamos superficialmente sobre los modificadores, para ver como modifican el acceso a los metodos desde otras clases. Espero les haya sido de utilidad y les dejo un link a GitHub donde estan los codigos creados hoy:

GitHub / Metodos

Les dejo algunas de mis redes sociales para seguirme o recibir una notificacion cada vez que subo un nuevo post: