Groovy - Métodos

Um método em Groovy é definido com um tipo de retorno ou com o defpalavra-chave. Os métodos podem receber qualquer número de argumentos. Não é necessário que os tipos sejam definidos explicitamente ao definir os argumentos. Modificadores como público, privado e protegido podem ser adicionados. Por padrão, se nenhum modificador de visibilidade for fornecido, o método é público.

O tipo mais simples de método é aquele sem parâmetros como o mostrado abaixo -

def methodName() { 
   //Method code 
}

A seguir está um exemplo de método simples

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();
   } 
}

No exemplo acima, DisplayName é um método simples que consiste em duas instruções println que são usadas para enviar algum texto para o console. Em nosso método principal estático, estamos apenas chamando o método DisplayName. A saída do método acima seria -

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

Parâmetros do Método

Um método é geralmente mais útil se seu comportamento é determinado pelo valor de um ou mais parâmetros. Podemos transferir valores para o método chamado usando os parâmetros do método. Observe que os nomes dos parâmetros devem ser diferentes uns dos outros.

O tipo mais simples de método com parâmetros como o mostrado abaixo -

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

A seguir está um exemplo de método simples com 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);
   } 
}

Neste exemplo, estamos criando um método de soma com 2 parâmetros, a e b. Ambos os parâmetros são do tipoint. Em seguida, estamos chamando o método de soma de nosso método principal e passando os valores para as variáveisa e b.

A saída do método acima seria o valor 15.

Parâmetros padrão

Também há uma provisão no Groovy para especificar valores padrão para parâmetros dentro de métodos. Se nenhum valor for passado ao método para os parâmetros, os valores padrão serão usados. Se forem usados ​​parâmetros não padrão e padrão, então deve-se observar que os parâmetros padrão devem ser definidos no final da lista de parâmetros.

A seguir está um exemplo de método simples com parâmetros -

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

Vejamos o mesmo exemplo que vimos antes para a adição de dois números e criar um método que tem um parâmetro padrão e outro não padrão -

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

Neste exemplo, estamos criando um método de soma com dois parâmetros, a e b. Ambos os parâmetros são do tipo int. A diferença entre este exemplo e o exemplo anterior é que, neste caso, estamos especificando um valor padrão parab como 5. Então, quando chamamos o método sum do nosso método principal, temos a opção de apenas passar um valor que é 6 e este será atribuído ao parâmetro a dentro do sum método.

A saída do método acima seria o 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);
   } 
}

Também podemos chamar o método de soma passando 2 valores, em nosso exemplo acima estamos passando 2 valores de 6. O segundo valor de 6 irá substituir o valor padrão que é atribuído ao parâmetro b.

A saída do método acima seria o valor 12.

Valores de retorno do método

Os métodos também podem retornar valores ao programa de chamada. Isso é necessário na linguagem de programação moderna, em que um método faz algum tipo de computação e retorna o valor desejado para o método de chamada.

A seguir está um exemplo de método simples com um 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));
   } 
}

Em nosso exemplo acima, observe que, desta vez, estamos especificando um tipo de retorno para nosso método sum, que é do tipo int. No método, estamos usando a instrução return para enviar o valor da soma ao programa principal de chamada. Uma vez que o valor do método agora está disponível para o método principal, estamos usando oprintln função para exibir o valor no console.

A saída do método acima seria o valor 11.

Métodos de instância

Os métodos são normalmente implementados dentro de classes dentro do Groovy, assim como a linguagem Java. Uma classe nada mais é do que um projeto ou modelo para a criação de diferentes objetos que definem suas propriedades e comportamentos. Os objetos de classe exibem as propriedades e comportamentos definidos por sua classe. Portanto, os comportamentos são definidos criando métodos dentro da classe.

Veremos as classes com mais detalhes em um capítulo posterior, mas a seguir está um exemplo de implementação de método em uma classe. Em nossos exemplos anteriores, definimos nosso método como métodos estáticos, o que significa que poderíamos acessar esses métodos diretamente da classe. O próximo exemplo de métodos são os métodos de instância em que os métodos são acessados ​​criando objetos da classe. Mais uma vez, veremos as classes em um capítulo posterior, por enquanto vamos demonstrar como usar métodos.

A seguir está um exemplo de como os métodos podem ser implementados.

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()); 
   } 
}

Em nosso exemplo acima, observe que, desta vez, não estamos especificando nenhum atributo estático para nossos métodos de classe. Em nossa função principal, estamos realmente criando uma instância da classe Example e, em seguida, invocando o método do objeto 'ex'.

A saída do método acima seria o valor 100.

Nomes de parâmetros locais e externos

Groovy fornece a facilidade, assim como o java, de ter parâmetros locais e globais. No exemplo a seguir,lx é um parâmetro local que tem escopo apenas dentro da função de getX() e xé uma propriedade global que pode ser acessada dentro de toda a classe Exemplo. Se tentarmos acessar a variávellx fora do getX() função, obteremos um erro.

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

Quando executarmos o programa acima, obteremos o seguinte resultado.

200 
100

este método para propriedades

Assim como em Java, o groovy pode acessar seus membros de instância usando o thispalavra-chave. O exemplo a seguir mostra como quando usamos a instruçãothis.x, ele se refere à sua instância e define o valor de x adequadamente.

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());
   }
}

Quando executarmos o programa acima, obteremos o resultado de 200 impresso no console.