Groovy - Métodos

Un método en Groovy se define con un tipo de retorno o con el defpalabra clave. Los métodos pueden recibir cualquier número de argumentos. No es necesario que los tipos se definan explícitamente al definir los argumentos. Se pueden agregar modificadores como público, privado y protegido. De forma predeterminada, si no se proporciona un modificador de visibilidad, el método es público.

El tipo más simple de método es uno sin parámetros como el que se muestra a continuación:

def methodName() { 
   //Method code 
}

A continuación se muestra un ejemplo de método simple

class Example {
   static def DisplayName() {
      println("This is how methods work in groovy");
      println("This is an example of a simple method");
   } 
	
   static void main(String[] args) {
      DisplayName();
   } 
}

En el ejemplo anterior, DisplayName es un método simple que consta de dos declaraciones println que se utilizan para enviar texto a la consola. En nuestro método principal estático, simplemente estamos llamando al método DisplayName. El resultado del método anterior sería:

This is how methods work in groovy 
This is an example of a simple method

Parámetros del método

Un método es más útil en general si su comportamiento está determinado por el valor de uno o más parámetros. Podemos transferir valores al método llamado usando parámetros de método. Tenga en cuenta que los nombres de los parámetros deben diferir entre sí.

El tipo más simple de un método con parámetros como el que se muestra a continuación:

def methodName(parameter1, parameter2, parameter3) { 
   // Method code goes here 
}

A continuación se muestra un ejemplo de método simple con parámetros

class Example {
   static void sum(int a,int b) {
      int c = a+b;
      println(c);
   }  
	
   static void main(String[] args) {
      sum(10,5);
   } 
}

En este ejemplo, estamos creando un método de suma con 2 parámetros, a y b. Ambos parámetros son de tipoint. Luego llamamos al método de suma desde nuestro método principal y pasamos los valores a las variablesa y b.

La salida del método anterior sería el valor 15.

Parámetros predeterminados

También hay una disposición en Groovy para especificar valores predeterminados para los parámetros dentro de los métodos. Si no se pasan valores al método para los parámetros, se utilizan los predeterminados. Si se utilizan tanto parámetros predeterminados como no predeterminados, debe tenerse en cuenta que los parámetros predeterminados deben definirse al final de la lista de parámetros.

A continuación se muestra un ejemplo de método simple con parámetros:

def someMethod(parameter1, parameter2 = 0, parameter3 = 0) { 
   // Method code goes here 
}

Veamos el mismo ejemplo que vimos antes para la suma de dos números y creemos un método que tiene un parámetro predeterminado y otro no predeterminado:

class Example { 
   static void sum(int a,int b = 5) { 
      int c = a+b; 
      println(c); 
   } 
	
   static void main(String[] args) {
      sum(6); 
   } 
}

En este ejemplo, estamos creando un método de suma con dos parámetros, a y b. Ambos parámetros son de tipo int. La diferencia entre este ejemplo y el ejemplo anterior es que en este caso estamos especificando un valor predeterminado parab como 5. Entonces, cuando llamamos al método suma desde nuestro método principal, tenemos la opción de pasar un valor que es 6 y este será asignado al parámetro a dentro de sum método.

La salida del método anterior sería el valor 11.

class Example {
   static void sum(int a,int b = 5) {
      int c = a+b;
      println(c);
   } 
	
   static void main(String[] args) {
      sum(6,6);
   } 
}

También podemos llamar al método de suma pasando 2 valores, en nuestro ejemplo anterior estamos pasando 2 valores de 6. El segundo valor de 6 realmente reemplazará el valor predeterminado que se asigna al parámetro b.

La salida del método anterior sería el valor 12.

Valores de retorno del método

Los métodos también pueden devolver valores al programa de llamada. Esto es necesario en el lenguaje de programación moderno, en el que un método realiza algún tipo de cálculo y luego devuelve el valor deseado al método de llamada.

A continuación se muestra un ejemplo de método simple con un valor de retorno.

class Example {
   static int sum(int a,int b = 5) {
      int c = a+b;
      return c;
   } 
	
   static void main(String[] args) {
      println(sum(6));
   } 
}

En nuestro ejemplo anterior, tenga en cuenta que esta vez estamos especificando un tipo de retorno para nuestro método sum que es del tipo int. En el método, estamos usando la declaración de retorno para enviar el valor de la suma al programa principal que llama. Dado que el valor del método ahora está disponible para el método principal, estamos usando elprintln función para mostrar el valor en la consola.

La salida del método anterior sería el valor 11.

Métodos de instancia

Los métodos se implementan normalmente dentro de clases dentro de Groovy al igual que el lenguaje Java. Una clase no es más que un plano o una plantilla para crear diferentes objetos que define sus propiedades y comportamientos. Los objetos de clase exhiben las propiedades y comportamientos definidos por su clase. Entonces, los comportamientos se definen creando métodos dentro de la clase.

Veremos las clases con más detalle en un capítulo posterior, pero a continuación se muestra un ejemplo de implementación de un método en una clase. En nuestros ejemplos anteriores, definimos nuestro método como métodos estáticos, lo que significaba que podíamos acceder a esos métodos directamente desde la clase. El siguiente ejemplo de métodos son los métodos de instancia en los que se accede a los métodos creando objetos de la clase. De nuevo veremos las clases en un capítulo posterior, por ahora demostraremos cómo usar los métodos.

A continuación se muestra un ejemplo de cómo se pueden implementar los métodos.

class Example { 
   int x; 
	
   public int getX() { 
      return x; 
   } 
	
   public void setX(int pX) { 
      x = pX; 
   } 
	
   static void main(String[] args) { 
      Example ex = new Example(); 
      ex.setX(100); 
      println(ex.getX()); 
   } 
}

En nuestro ejemplo anterior, tenga en cuenta que esta vez no especificamos ningún atributo estático para nuestros métodos de clase. En nuestra función principal, en realidad estamos creando una instancia de la clase Example y luego invocamos el método del objeto 'ex'.

La salida del método anterior sería el valor 100.

Nombres de parámetros locales y externos

Groovy proporciona la facilidad como Java para tener parámetros locales y globales. En el siguiente ejemplo,lx es un parámetro local que tiene un alcance solo dentro de la función de getX() y xes una propiedad global a la que se puede acceder dentro de toda la clase Example. Si intentamos acceder a la variablelx fuera del getX() función, obtendremos un error.

class Example { 
   static int x = 100; 
	
   public static int getX() { 
      int lx = 200; 
      println(lx); 
      return x; 
   } 
	
   static void main(String[] args) { 
      println(getX()); 
   }  
}

Cuando ejecutamos el programa anterior, obtendremos el siguiente resultado.

200 
100

este método para Propiedades

Al igual que en Java, groovy puede acceder a los miembros de su instancia utilizando el thispalabra clave. El siguiente ejemplo muestra cómo cuando usamos la declaraciónthis.x, se refiere a su instancia y establece el valor de x en consecuencia.

class Example { 
   int x = 100; 
	
   public int getX() { 
      this.x = 200; 
      return x; 
   } 
	
   static void main(String[] args) {
      Example ex = new Example(); 
      println(ex.getX());
   }
}

Cuando ejecutamos el programa anterior, obtendremos el resultado de 200 impreso en la consola.