Es importante saber que los métodos o funciones en java, van siempre dentro de una clase. Aunque lo más habitual es que se declaren en clases independientes, también pueden declararse en la clase principal, (la que tiene el método main).
Por otra parte, estos métodos o funciones en java, suelen declararse dentro de clases en las que se construyen objetos. Esto es debido a que los métodos o funciones, indican lo que un objeto puede hacer. Por este mótivo es fundamental saber como se utilizan, ya que son la base de la programación orientada a objetos (POO).
Tipos de métodos o funciones.
Dentro de los tipos de métodos o funciones en java podemos aquellas que son de tipo void (que no devuelven nada) o aquellas que devuelven un valor (en éstas ultimas, utilizaremos la cláusula return).
Además tanto los métodos void como las que devuelven algún valor, pueden recibir parámetros o argumentos de forma opcional.
Métodos de tipo void.
Son métodos que no devuelven ningún tipo de valor. Solo ejecutan código que tengan en su interior cuando son llamados. Este tipo de métodos pueden recibir o no parámetros o argumentos de forma opcional.
Ejemplo de método tipo void sin paso de parámetros.
package arranque;
/* Importamos el paquete donde se encuentra la clase Scanner*/
import java.util.*;
public class Principal {
/* Creamos un método de tipo void que haga un menú*/
private static void mostrarMenu() {
System.out.println("1. Primer ejercicio");
System.out.println("2. Segundo ejercicio");
System.out.println("3. Tercer ejercicio");
System.out.println("4. Cuarto ejercicio");
System.out.println("5. Quinto ejercicio");
System.out.println("6. Salir");
}
public static void main(String[] args) {
/* Creamos un objeto de tipo Scanner*/
Scanner lectura=new Scanner(System.in);
/* Creamos una variable para guardar la opcion del usuario*/
int elegirOpcion;
/* Hacemos como mínimo una vez lo siguiente*/
do {
/* Mostramos el menú llamando al método mostrarMenu();*/
mostrarMenu();
/* Pedimos al usuario que introduzca una opción*/
System.out.print("Introduce una opción: ");
/* Guardamos la opcion en la variable elegirOpcion*/
elegirOpcion=lectura.nextInt();
/* Todo esto lo hacemos mientras el usuario introduzca
* un número menor que uno o un número mayor que seis*/
}while(elegirOpcion<1 || elegirOpcion>6);
/* AQUI PUEDE HABER MÁS INSTRUCCIONES....*/
// Al final cerramos el objeto lectura
lectura.close();
}
}
En este caso estamos creando el método dentro de la clase donde se encuentra el método main. Además vemos que lo único que estamos haciendo es ejecutar una serie de instrucciones llamando a la función «mostrarMenu()» desde el propio main.
En este caso al crear la función en la clase principal, el propio IDE Eclipse, nos obliga a que el método sea de tipo static.
Ejemplo de métodos tipo void con paso de parámetros.
En java, el paso de parámetros se realiza siempre por valor. Por lo tanto en este ejemplo veremos como sería la creación de una función en java con paso de parámetros por ejemplo para saludar a una persona.
package arranque;
/* Importamos el paquete donde se encuentra la clase Scanner*/
import java.util.*;
public class Principal {
/* Creamos un método de tipo void que recibe
* un parámentro y saluda al usuario.*/
private static void saludar(String pNombre) {
System.out.println("Hola " + pNombre + "¡soy un método "
+ "en java que te está saludando!");
}
public static void main(String[] args) {
/* Creamos un objeto de tipo Scanner*/
Scanner lectura=new Scanner(System.in);
/* Creamos una variable para guardar el nombre*/
String nombre;
/* Pedimos el nombre al usuario*/
System.out.print("Introduce tu nombre: ");
/* Guardamos el nombre en la variable nombre*/
nombre=lectura.nextLine();
/* Llamamos a la función pasandole el nombre
* que el usuario ha introducido por teclado*/
saludar(nombre);
}
}
En este último caso, el usuario escribe un nombre que se guarda en la variable nombre, declarada en el método main. Ese valor, viajará y se guardará en el parámetro de la función pNombre. Eso se lo indicamos a java, en los paréntesis del método al que llamamos desde el método máin.
Métodos que devuelven un valor.
Este tipo de funciones, al igual que las anteriores también se ejecutan cuando se llaman desde otro método o función. La diferencia es que estás ultimas devuelven un valor o un objeto, por lo que es indispensable hacer uso de la palabra “return”. En este caso, este tipo de funciones, también pueden recibir de forma opcional parámetros o argumentos.
Ejemplo de funciones que devuelven un valor sin recibir parámetros.
package arranque;
/* Importamos el paquete donde se encuentra la clase Scanner*/
import java.util.*;
public class Principal {
/* Creamos un método de tipo void que recibe
* un parámentro y saluda al usuario.*/
public static String saludar() {
return "Eres un aprendiz de programador en java";
}
public static void main(String[] args) {
/* Creamos un objeto de tipo Scanner*/
Scanner lectura=new Scanner(System.in);
/* Creamos una variable para guardar el nombre*/
String nombre;
/* Creamos una variable para guardar
* el resultado de la funcion.*/
String resultadoFuncion;
/* Pedimos el nombre al usuario*/
System.out.print("Introduce tu nombre: ");
/* Guardamos el nombre en la variable nombre*/
nombre=lectura.nextLine();
/* Ahora guardamos el resultado de la funcion
* en la variable que hemos creado.*/
resultadoFuncion=saludar();
/* Ahora mostramos un mensaje concatenando el nombre
* con el resultado de la funcion.*/
System.out.println("Hola " + nombre + ". " + resultadoFuncion);
/* Cerramos el objeto de lectura*/
lectura.close();
}
}
En este caso es una función que devuelve un valor de tipo String. Por este motivo, para mostrar el resultado de la función en el método main se declara una variable extra llamada resultadoFuncion.
Es importante saber que, todas las funciones en java que devuelven un valor, ese valor debe ser almacenado en una variable del mismo tipo de dato que devuelve la funcion, ya que en caso contrario, no podemos mostrar su resultado.
Funciones que devuelven un valor recibiendo parámetros.
package arranque;
/* Importamos el paquete donde se encuentra la clase Scanner*/
import java.util.*;
public class Principal {
/* Creamos un método de tipo void que recibe
* un parámentro y saluda al usuario.*/
private static String saludar(String pNombre) {
return "Hola " + pNombre +
". Eres un aprendiz de programador en java";
}
public static void main(String[] args) {
/* Creamos un objeto de tipo Scanner*/
Scanner lectura=new Scanner(System.in);
/* Creamos una variable para guardar el nombre*/
String nombre;
/* Creamos una variable para guardar
* el resultado de la funcion.*/
String resultadoFuncion;
/* Pedimos el nombre al usuario*/
System.out.print("Introduce tu nombre: ");
/* Guardamos el nombre en la variable nombre*/
nombre=lectura.nextLine();
/* Ahora guardamos el resultado de la funcion
* en la variable que hemos creado.*/
resultadoFuncion=saludar(nombre);
/* Ahora mostramos un mensaje concatenando el nombre
* con el resultado de la funcion.*/
System.out.println(resultadoFuncion);
/* Cerramos el objeto de lectura*/
lectura.close();
}
}
En este caso es muy parecido al ejemplo anterior, lo único que cambia es que esta recibiendo por parámetro el nombre que el usuario está introduciendo por teclado y lo que está imprimiendo en pantalla es la variable que contiene el resultado de la función.
Métodos o funciones de tipo static.
Es importante destacar que un método, puede ser o no static (estático). Esto quiere decir que si es lleva la palabra reservada “static”, se debe anteponer antes que el método el nombre de la clase a la que éste pertenece.
Cuando creamos métodos o variable (a nivel de clase) dentro de la clase que contiene el método main, este tipo de métodos o variables, deben ser de tipo static para poder utilizarse. Veamos un ejemplo sencillo con la declaración de variables.
Ejemplo del uso de static en los campos de clase.
package arranque;
public class Principal {
int num =0;
public static void main(String[] args) {
System.out.println("El número de la variable es " + num );
}
}
Como se puede ver en este ejemplo, tenemos una variable «num», declarada a nivel de clase dentro de la clase Principal, que contiene el método main.
En este caso, al declarar la variable, el propio eclipse, nos mostrará una advertencia. A la altura de la declaración de dicha variable nos informa que de que el valor de la variable no está siendo usado.
Por otra parte, al mostrar por pantalla el contenido de dicha variable, la instrucción dentro del método main, nos está dando un error. Este error nos informa de que no se puede hacer una referencia estática a un campo que no es estático. Por lo tanto en este caso el ejemplo no estaría correcto.
Para solucionar estos errores solo debemos hacer estática dicha variable con la palabra reservada «static«. Esto lo haremos de la siguiente manera.
package arranque;
public class Principal {
static int num =0;
public static void main(String[] args) {
System.out.println("El número de la variable es " + num );
}
}
Ejemplo de uso de static en métodos o funciones.
Al igual que con los campos de clase o variables, el uso de la palabra reservada static funciona de la misma manera. Vamos a ver un ejemplo que no sería correcto.
package arranque;
public class Principal {
public static void main(String[] args) {
saludar();
}
private void saludar() {
System.out.println("Hola aprendiz de programador en java");
}
}
Es este caso, cuando arranca el programa, éste llama a una función que saluda al usuario. Sin embargo, este código no se ejecutará y dará el mismo error que en el caso de las variables o los campos de clase. En este caso la función o método, debe declararse como estático para poder utilizarlo.
Por tanto el ejemplo correcto sería declarando el método saludar como static:
package arranque;
public class Principal {
public static void main(String[] args) {
saludar();
}
private static void saludar() {
System.out.println("Hola aprendiz de programador en java");
}
}