Groovy - Méthodes

Une méthode est dans Groovy est définie avec un type de retour ou avec le defmot-clé. Les méthodes peuvent recevoir n'importe quel nombre d'arguments. Il n'est pas nécessaire que les types soient explicitement définis lors de la définition des arguments. Des modificateurs tels que public, privé et protégé peuvent être ajoutés. Par défaut, si aucun modificateur de visibilité n'est fourni, la méthode est publique.

Le type de méthode le plus simple est celui sans paramètres comme celui indiqué ci-dessous -

def methodName() { 
   //Method code 
}

Voici un exemple de méthode 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();
   } 
}

Dans l'exemple ci-dessus, DisplayName est une méthode simple qui se compose de deux instructions println qui sont utilisées pour sortir du texte vers la console. Dans notre méthode principale statique, nous appelons simplement la méthode DisplayName. Le résultat de la méthode ci-dessus serait -

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

Paramètres de méthode

Une méthode est plus généralement utile si son comportement est déterminé par la valeur d'un ou plusieurs paramètres. Nous pouvons transférer des valeurs vers la méthode appelée en utilisant des paramètres de méthode. Notez que les noms de paramètres doivent différer les uns des autres.

Le type le plus simple d'une méthode avec des paramètres comme celui indiqué ci-dessous -

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

Voici un exemple de méthode simple avec des paramètres

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

Dans cet exemple, nous créons une méthode de somme avec 2 paramètres, a et b. Les deux paramètres sont de typeint. Nous appelons ensuite la méthode sum de notre méthode principale et transmettons les valeurs aux variablesa et b.

La sortie de la méthode ci-dessus serait la valeur 15.

Paramètres par défaut

Il existe également une disposition dans Groovy pour spécifier des valeurs par défaut pour les paramètres dans les méthodes. Si aucune valeur n'est transmise à la méthode pour les paramètres, les valeurs par défaut sont utilisées. Si des paramètres non par défaut et par défaut sont utilisés, il convient de noter que les paramètres par défaut doivent être définis à la fin de la liste des paramètres.

Voici un exemple de méthode simple avec des paramètres -

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

Regardons le même exemple que nous avons vu précédemment pour l'ajout de deux nombres et créons une méthode qui a un paramètre par défaut et un autre paramètre non par défaut -

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

Dans cet exemple, nous créons une méthode de somme avec deux paramètres, a et b. Les deux paramètres sont de type int. La différence entre cet exemple et l'exemple précédent est que dans ce cas, nous spécifions une valeur par défaut pourb comme 5. Ainsi, lorsque nous appelons la méthode sum de notre méthode principale, nous avons la possibilité de simplement passer une valeur qui est 6 et celle-ci sera affectée au paramètre a dans le sum méthode.

La sortie de la méthode ci-dessus serait la valeur 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);
   } 
}

Nous pouvons également appeler la méthode sum en passant 2 valeurs, dans notre exemple ci-dessus, nous passons 2 valeurs de 6. La deuxième valeur de 6 remplacera en fait la valeur par défaut qui est assignée au paramètre b.

La sortie de la méthode ci-dessus serait la valeur 12.

Valeurs de retour de méthode

Les méthodes peuvent également renvoyer des valeurs au programme appelant. Ceci est requis dans le langage de programmation moderne dans lequel une méthode effectue une sorte de calcul, puis renvoie la valeur souhaitée à la méthode appelante.

Voici un exemple de méthode simple avec une valeur de retour.

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

Dans notre exemple ci-dessus, notez que cette fois, nous spécifions un type de retour pour notre méthode sum qui est du type int. Dans la méthode, nous utilisons l'instruction return pour envoyer la valeur de la somme au programme principal appelant. La valeur de la méthode étant désormais disponible pour la méthode principale, nous utilisons laprintln fonction pour afficher la valeur dans la console.

La sortie de la méthode ci-dessus serait la valeur 11.

Méthodes d'instance

Les méthodes sont normalement implémentées dans les classes de Groovy, tout comme le langage Java. Une classe n'est rien d'autre qu'un plan ou un modèle pour créer différents objets qui définissent ses propriétés et ses comportements. Les objets de classe présentent les propriétés et les comportements définis par sa classe. Ainsi, les comportements sont définis en créant des méthodes à l'intérieur de la classe.

Nous verrons les classes plus en détail dans un chapitre ultérieur, mais voici un exemple d'implémentation de méthode dans une classe. Dans nos exemples précédents, nous avons défini notre méthode comme des méthodes statiques, ce qui signifiait que nous pouvions accéder à ces méthodes directement depuis la classe. L'exemple suivant de méthodes est celui des méthodes d'instance dans lesquelles les méthodes sont accessibles en créant des objets de la classe. Encore une fois, nous verrons les classes dans un chapitre ultérieur, pour l'instant nous montrerons comment utiliser les méthodes.

Voici un exemple de la façon dont les méthodes peuvent être implémentées.

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

Dans notre exemple ci-dessus, notez que cette fois, nous ne spécifions aucun attribut statique pour nos méthodes de classe. Dans notre fonction principale, nous créons en fait une instance de la classe Example, puis nous invoquons la méthode de l'objet 'ex'.

La sortie de la méthode ci-dessus serait la valeur 100.

Noms des paramètres locaux et externes

Groovy fournit la possibilité, tout comme Java, d'avoir des paramètres locaux et globaux. Dans l'exemple suivant,lx est un paramètre local qui n'a une portée que dans la fonction de getX() et xest une propriété globale accessible dans toute la classe Example. Si nous essayons d'accéder à la variablelx en dehors de la getX() fonction, nous obtiendrons une erreur.

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

Lorsque nous exécutons le programme ci-dessus, nous obtiendrons le résultat suivant.

200 
100

cette méthode pour les propriétés

Tout comme en Java, groovy peut accéder à ses membres d'instance en utilisant le thismot-clé. L'exemple suivant montre comment lorsque nous utilisons l'instructionthis.x, il fait référence à son instance et définit la valeur de x en conséquence.

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

Lorsque nous exécutons le programme ci-dessus, nous obtiendrons le résultat de 200 imprimé sur la console.