Métodos en Java

Un método es un bloque de código que sólo se ejecuta cuando se le llama.

Puede pasar datos, conocidos como parámetros, a un método.

Los métodos se utilizan para realizar ciertas acciones, y también se conocen como funciones.

¿Por qué usar métodos? Para reutilizar el código: defina el código una vez y use muchas veces.


  Crear un método

Un método debe declararse dentro de una clase. Se define con el nombre del método, seguido de paréntesis ( ). Java proporciona algunos métodos predefinidos, como System.out.println(), pero también puede crear sus propios métodos para realizar ciertas acciones:

  Ejemplo 1

Cree un método dentro de Main:

  public class Main {
    static void myMethod() {
      // Código a ejecutar
    }
  }

Ejemplo explicado

🟡 myMethod( ), es el nombre del método.
🟡 static significa que el método que pertenece a la Clase principal y no un objeto de la clase principal. Aprenderá más sobre los objetos y cómo acceder a los métodos a través de objetos más adelante en este tutorial.
🟡 void significa que este método no tiene un valor devuelto. Aprenderá más sobre los valores devueltos más adelante en este capítulo


  Llamar un método

Para llamar a un método en Java, escriba el nombre del método seguido de dos paréntesis ( ) y punto y coma ;

En el siguiente ejemplo, se utiliza para imprimir un texto (la acción), cuando se llama: myMethod( )


  Ejemplo 2

Dentro de main, llame al método myMethod( ): 

  public class Main {
    static void myMethod() {
      System.out.println("Acabo de ser ejecutado!");
    }
        
    public static void main(String[] args) {
      myMethod();
    }
  }
  // Salida "Acabo de ser ejecutado"

Quiero intentarlo

También se puede llamar a un método varias veces:

  Ejemplo 3

  public class Main {
    static void myMethod() {
      System.out.println("Acabo de ser ejecutado!");
    }
        
    public static void main(String[] args) {
      myMethod();
      myMethod();
      myMethod();
    }
  }
        
  // Acabo de ser ejecutado!
  // Acabo de ser ejecutado!
  // Acabo de ser ejecutado!

Quiero intentarlo


  Parámetros en métodos Java

La información se puede pasar a los métodos como parámetro. Los parámetros actúan como variables dentro del método.

Los parámetros se especifican después del nombre del método, dentro de los paréntesis. Puede agregar tantos parámetros como desee, simplemente sepárelos con una coma.

El ejemplo siguiente tiene un Método que toma un llamado fname como parámetro. Cuando se llama al método, pasamos un nombre, que se utiliza dentro del método para imprimir el nombre completo: String

Ejemplo 4

  public class Main {
    static void myMethod(String fname) {
      System.out.println(fname + " Refsnes");
    }
        
    public static void main(String[] args) {
      myMethod("Liam");
      myMethod("Jenny");
      myMethod("Anja");
    }
  }
  // Liam Refsnes
  // Jenny Refsnes
  // Anja Refsnes

Quiero intentarlo

Cuando se pasa un parámetro al método, se denomina argumento Entonces, del ejemplo anterior: fname es un parámetro, mientras que Liam, Jenny y Anja son argumentos.

  Múltiples parámetros

Puedes tener tantos parámetros como quieras:

Ejemplo 4

  public class Main {
    static void myMethod(String fname, int age) {
      System.out.println(fname + " is " + age);
    }
        
    public static void main(String[] args) {
      myMethod("Liam", 5);
      myMethod("Jenny", 8);
      myMethod("Anja", 31);
    }
  }        
  // Liam es 5
  // Jenny es 8
  // Anja e 31

Quiero intentarlo

Tenga en cuenta que cuando se trabaja con varios parámetros, la llamada al método debe tienen el mismo número de argumentos que parámetros, y los argumentos deben pasarse en el mismo orden.

  Valores devueltos

La palabra clave void, utilizada en los ejemplos anteriores, indica que el método no debe devolver un valor. Si usted Si desea que el método devuelva un valor, puede utilizar un tipo de datos primitivo (como int, char, etc.) en lugar de void, y utilizar la palabra clave return dentro del método:

Ejemplo 5

  public class Main {
    static int myMethod(int x) {
      return 5 + x;
    }
       
    public static void main(String[] args) {
      System.out.println(myMethod(3));
    }
  }
  // Salida 8 (5 + 3)

Quiero intentarlo

En este ejemplo se devuelve la suma de los dos parámetros de un método:

Ejemplo 6

  public class Main {
    static int myMethod(int x, int y) {
      return x + y;
    }
        
    public static void main(String[] args) {
      System.out.println(myMethod(5, 3));
    }
  }
  // Salida 8 (5 + 3)

Quiero intentarlo

También puede almacenar el resultado en una variable (recomendado, ya que es más fácil de leer y mantener):

Ejemplo 7

  public class Main {
    static int myMethod(int x, int y) {
      return x + y;
    }
        
    public static void main(String[] args) {
      int z = myMethod(5, 3);
      System.out.println(z);
    }
  }
  // Salida 8 (5 + 3)

Quiero intentarlo

  Método con if... else

Es común usar instrucciones if...else dentro de los métodos:

Ejemplo 8

  public class Main(){

    // Crear un método checkAge() con una variable entera llamada age
    static void checkAge(int age) {
      // Si la edad es menor a 18, mostrar "acceso denegado"
      if (age < 18) {
        System.out.println("Acceso denegado - No eres mayor!");
        
        // Si age es mayor o igual a 18, mostrar "acceso permitido"
      } else {
        System.out.println("Acceso permitido - Eres mayor!");
      }
        
    }
        
    public static void main(String[] args) {
      checkAge(20); // Llamamos al método checkAge y pasamos la edad de 20
    }
  }    
  // Obtendremos "Acceso permitido - Eres mayor!"

Quiero intentarlo

Anterior Volver al inicio Siguiente