Groovy - Metodi

Un metodo in Groovy è definito con un tipo restituito o con defparola chiave. I metodi possono ricevere un numero qualsiasi di argomenti. Non è necessario che i tipi siano definiti in modo esplicito durante la definizione degli argomenti. È possibile aggiungere modificatori come public, private e protected. Per impostazione predefinita, se non viene fornito alcun modificatore di visibilità, il metodo è pubblico.

Il tipo più semplice di un metodo è quello senza parametri come quello mostrato di seguito -

def methodName() { 
   //Method code 
}

Di seguito è riportato un esempio di metodo semplice

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

Nell'esempio precedente, DisplayName è un metodo semplice che consiste in due istruzioni println che vengono utilizzate per inviare del testo alla console. Nel nostro metodo principale statico, stiamo solo chiamando il metodo DisplayName. L'output del metodo sopra sarebbe:

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

Parametri del metodo

Un metodo è più generalmente utile se il suo comportamento è determinato dal valore di uno o più parametri. Possiamo trasferire valori al metodo chiamato utilizzando i parametri del metodo. Notare che i nomi dei parametri devono differire l'uno dall'altro.

Il tipo più semplice di un metodo con parametri come quello mostrato di seguito -

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

Di seguito è riportato un esempio di metodo semplice con parametri

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

In questo esempio, stiamo creando un metodo di somma con 2 parametri, a e b. Entrambi i parametri sono di tipoint. Chiamiamo quindi il metodo sum dal nostro metodo principale e passiamo i valori alle variabilia e b.

L'output del metodo sopra sarebbe il valore 15.

Parametri predefiniti

C'è anche una disposizione in Groovy per specificare i valori predefiniti per i parametri all'interno dei metodi. Se non vengono passati valori al metodo per i parametri, vengono utilizzati quelli di default. Se vengono utilizzati sia parametri non predefiniti che parametri predefiniti, è necessario notare che i parametri predefiniti devono essere definiti alla fine dell'elenco dei parametri.

Di seguito è riportato un esempio di metodo semplice con parametri:

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

Diamo un'occhiata allo stesso esempio che abbiamo visto prima per l'aggiunta di due numeri e creiamo un metodo che ha un parametro predefinito e un altro non predefinito -

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

In questo esempio, stiamo creando un metodo di somma con due parametri, a e b. Entrambi i parametri sono di tipo int. La differenza tra questo esempio e quello precedente è che in questo caso stiamo specificando un valore predefinito perb come 5. Quindi quando chiamiamo il metodo sum dal nostro metodo principale, abbiamo la possibilità di passare solo un valore che è 6 e questo verrà assegnato al parametro a all'interno del sum metodo.

L'output del metodo sopra sarebbe il valore 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);
   } 
}

Possiamo anche chiamare il metodo sum passando 2 valori, nel nostro esempio sopra stiamo passando 2 valori di 6. Il secondo valore di 6 sostituirà effettivamente il valore predefinito assegnato al parametro b.

L'output del metodo sopra sarebbe il valore 12.

Valori restituiti dal metodo

I metodi possono anche restituire valori al programma chiamante. Ciò è richiesto nel linguaggio di programmazione moderno in cui un metodo esegue una sorta di calcolo e quindi restituisce il valore desiderato al metodo chiamante.

Di seguito è riportato un esempio di metodo semplice con un valore di ritorno.

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

Nel nostro esempio sopra, nota che questa volta stiamo specificando un tipo di ritorno per il nostro metodo sum che è del tipo int. Nel metodo stiamo usando l'istruzione return per inviare il valore della somma al programma principale chiamante. Poiché il valore del metodo è ora disponibile per il metodo principale, stiamo usando ilprintln funzione per visualizzare il valore nella console.

L'output del metodo sopra sarebbe il valore 11.

Metodi di istanza

I metodi sono normalmente implementati all'interno di classi all'interno di Groovy proprio come il linguaggio Java. Una classe non è altro che un progetto o un modello per creare diversi oggetti che ne definiscono le proprietà e i comportamenti. Gli oggetti della classe mostrano le proprietà e i comportamenti definiti dalla sua classe. Quindi i comportamenti vengono definiti creando metodi all'interno della classe.

Vedremo le classi più in dettaglio in un capitolo successivo, ma di seguito è riportato un esempio di implementazione di un metodo in una classe. Nei nostri esempi precedenti abbiamo definito il nostro metodo come metodi statici, il che significava che potevamo accedere a quei metodi direttamente dalla classe. Il prossimo esempio di metodi sono i metodi di istanza in cui si accede ai metodi creando oggetti della classe. Di nuovo vedremo le classi in un capitolo successivo, per ora mostreremo come utilizzare i metodi.

Di seguito è riportato un esempio di come i metodi possono essere implementati.

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

Nel nostro esempio precedente, nota che questa volta non stiamo specificando alcun attributo statico per i nostri metodi di classe. Nella nostra funzione principale stiamo effettivamente creando un'istanza della classe Example e quindi invocando il metodo dell'oggetto "ex".

L'output del metodo sopra sarebbe il valore 100.

Nomi dei parametri locali ed esterni

Groovy fornisce la struttura, proprio come java, per avere parametri locali e globali. Nell'esempio seguente,lx è un parametro locale che ha un ambito solo all'interno della funzione di getX() e xè una proprietà globale a cui è possibile accedere all'interno dell'intera classe Example. Se proviamo ad accedere alla variabilelx al di fuori del getX() funzione, avremo un errore.

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 eseguiamo il programma sopra, otterremo il seguente risultato.

200 
100

questo metodo per le proprietà

Proprio come in Java, groovy può accedere ai membri dell'istanza utilizzando l'estensione thisparola chiave. Il seguente esempio mostra come quando usiamo l'istruzionethis.x, fa riferimento alla sua istanza e imposta il valore di x di conseguenza.

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 eseguiamo il programma precedente, otterremo il risultato di 200 stampato sulla console.