Un método es un bloque de instrucciones definidas dentro de una clase que realizan una determinada tarea y a las que podemos invocar (llamar) mediante un nombre identificador.

Los métodos pueden ser de dos tipos:

• Métodos estáticos: se definen como static
• Métodos de instancia

En este tema nos centramos en los métodos estáticos.

Algunos de los métodos estáticos que hemos usado hasta ahora:

//Se ejecutan desde la clase
System.out.println("Introduce un valor");
Math.random();

También hemos usado métodos no estáticos (de instancia) a partir de algunos objetos:

//Es necesario construir un objeto
String cadena = "Fernando";
Scanner input = new Scanner(System.in);
 
//se llama a sus métodos a partir del objeto creado
cadena.charAt(4);
input.nextLine();

Si usamos métodos:

• Se modulariza el código
• Se permite reutilizar el código, sin tener que volver a escribirlo.

[modificadores] tipoRetorno identificadorMetodo([lista parametros])
{
   // instrucciones 
   [return valor;] 
}

• Modificadores: public, private, static
• Tipo retorno: Tipo de datos que devuelve el método. Puede devolver un tipo concreto, o no devolver nada: void
• Identificador: El identificador que usaremos para ejecutarlo, igual que el de una variable. Su forma de escribir el identificador de un método es lowerCamelCase
• Lista de parámetros: Los tipos de datos que necesita el método para operar.
• Return: se usa para devolver el valor de retorno. El tipo retornado tiene que coincidir con el tipo retorno del método.

static int sumar(int entero1, int entero2){ 
   int resultado; 
   resultado = entero1 + entero2; 
   return resultado; 
}

Definimos como void los métodos que no devuelven un valor. Harán cosas pero no devuelven un valor. Normalmente muestran datos por pantalla.

void es una palabra reservada que se usa solo para indicar que un método no retorna nada. No se pueden crear variables de tipo void.

static void sumar(int entero1, int entero2){ 
   int resultado; 
   resultado = entero1 + entero2; 
   System.out.println("La suma es: " + resultado); 
}

Aunque no devuelva nada, podemos seguir usando la instrucción return, si hay algún caso especial en el que queremos que el método termine.

Por ahora, la principal característica que nos interesa de la cláusula static es que para usar un método static no necesitamos crear un objeto de la clase en la que se encuentra definido.

Por ejemplo: todos los métodos de la clase Math, son estáticos, y no necesitamos crear una variable de tipo Math para ejecutarlos.

La clase String tiene algunos métodos que también son estáticos, pero otros que solo los puedo ejecutar desde una variable de tipo String.

Se indicará al comienzo de la definición de un método, cuando quiero poder usarlo desde clases que se encuentran en otros packages.

package metodos;
 
public class Metodo1{ 
   public static void main(String[] args) { 
      int num1 = 3, num2 = 5; 
      System.out.println("La suma es: " + sumar(num1, num2)); 
   } 
 
   public static int sumar(int entero1, int entero2){ 
      int resultado; 
      resultado = entero1 + entero2; 
      return resultado; 
   }
}

Y lo usamos desde una clase en otro package:

package ejercicios;
 
//Debo importar la clase que lo contiene
import metodos.Metodo1;
 
public class Ejercicio1 { 
   public static void main(String[] args) { 
      int num1 = 3;
      int num2 = 5; 
      //Lo uso poniendo delante el nombre de la clase
      System.out.println("La suma es: " + Metodo1.sumar(num1, num2)); 
   } 
}

Java nos permite crear métodos dentro de la misma clase y con el mismo identificador. Esto se conoce como sobrecarga overloading.

Para que dos métodos puedan tener el mismo nombre debe haber alguna de estas diferencias entre ellos:

• Diferencia en la cantidad de parámetros que reciben.
• Diferencia en el tipo de parámetros que reciben.

Ejemplos de clases con sobrecarga de métodos son las clases Math o String:

Como vemos hay varios métodos repetidos, pero tienen alguna diferencia entre el tipo del parámetro o la cantidad de parámetros que reciben.

Se conoce con el nombre de recursividad a la técnica en la que un método hace una llamada a sí mismo. Es una técnica muy potente, pero también muy pesada (consumo de recursos).

Ejemplo de método recursivo para obtener el valor factorial (1 x 2 x 3 x … x N) de un entero positivo (N):

static int factorial(int entero){ 
 
   //Condición de salida de recursividad
   if (entero == 0){
      return 1; 
   }    
 
   //LLamada recursiva
   return factorial(entero - 1) * entero; 
}

© 2024 Fernando Valdeón