Java - Méthodes

Une méthode Java est une collection d'instructions qui sont regroupées pour effectuer une opération. Lorsque vous appelez System.out.println() méthode, par exemple, le système exécute en fait plusieurs instructions afin d'afficher un message sur la console.

Vous allez maintenant apprendre à créer vos propres méthodes avec ou sans valeurs de retour, à invoquer une méthode avec ou sans paramètres et à appliquer l'abstraction de méthode dans la conception du programme.

Méthode de création

Considérant l'exemple suivant pour expliquer la syntaxe d'une méthode −

Syntaxe

public static int methodName(int a, int b) {
   // body
}

Ici,

public statique − modificateur
entier − type de retour
methodName − nom de la méthode
un, b − paramètres formels
entier a, entier b − liste des paramètres

La définition de méthode se compose d'un en-tête de méthode et d'un corps de méthode. La même chose est montrée dans la syntaxe suivante −

Syntaxe

modifier returnType nameOfMethod (Parameter List) {
   // method body
}

La syntaxe ci-dessus inclut −

modificateur − Il définit le type d'accès de la méthode et son utilisation est facultative.
type de retour − La méthode peut renvoyer une valeur.
nomDeMéthode − C'est le nom de la méthode. La signature de la méthode se compose du nom de la méthode et de la liste des paramètres.
Liste des paramètres − La liste des paramètres, c'est le type, l'ordre et le nombre de paramètres d'une méthode. Ceux-ci sont facultatifs, la méthode peut contenir zéro paramètre.
corps de la méthode − Le corps de la méthode définit ce que la méthode fait avec les instructions.

Exemple

Voici le code source de la méthode définie ci-dessus appelée min() . Cette méthode prend deux paramètres num1 et num2 et renvoie le maximum entre les deux −

/** the snippet returns the minimum between two numbers */

public static int minFunction(int n1, int n2) {
   int min;
   if (n1 > n2)
      min = n2;
   else
      min = n1;

   return min; 
}

Méthode d'appel

Pour utiliser une méthode, il faut l'appeler. Il existe deux façons d'appeler une méthode, c'est-à-dire que la méthode renvoie une valeur ou ne renvoie rien (pas de valeur de retour).

Le processus d'appel de méthode est simple. Lorsqu'un programme invoque une méthode, le contrôle du programme est transféré à la méthode appelée. Cette méthode appelée rend alors le contrôle à l'appelant dans deux conditions, lorsque −

l'instruction return est exécutée.
il atteint l'accolade fermante de fin de méthode.

Les méthodes renvoyant void sont considérées comme un appel à une instruction. Prenons un exemple −

System.out.println("This is tutorialspoint.com!");

La méthode renvoyant la valeur peut être comprise par l'exemple suivant −

int result = sum(6, 9);

Voici l'exemple pour montrer comment définir une méthode et comment l'appeler −

Exemple

Démo en direct

public class ExampleMinNumber {
   
   public static void main(String[] args) {
      int a = 11;
      int b = 6;
      int c = minFunction(a, b);
      System.out.println("Minimum Value = " + c);
   }

   /** returns the minimum of two numbers */
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

Cela produira le résultat suivant −

Sortie

Minimum value = 6

Le mot-clé vide

Le mot-clé void nous permet de créer des méthodes qui ne retournent pas de valeur. Ici, dans l'exemple suivant, nous considérons une méthode vide methodRankPoints . Cette méthode est une méthode void, qui ne renvoie aucune valeur. L'appel à une méthode void doit être une déclaration, c'est-à-dire methodRankPoints(255.7); . Il s'agit d'une instruction Java qui se termine par un point-virgule, comme illustré dans l'exemple suivant.

Exemple

Démo en direct

public class ExampleVoid {

   public static void main(String[] args) {
      methodRankPoints(255.7);
   }

   public static void methodRankPoints(double points) {
      if (points >= 202.5) {
         System.out.println("Rank:A1");
      }else if (points >= 122.4) {
         System.out.println("Rank:A2");
      }else {
         System.out.println("Rank:A3");
      }
   }
}

Cela produira le résultat suivant −

Sortie

Rank:A1

Transmettre des paramètres par valeur

Tout en travaillant sous le processus d'appel, les arguments doivent être passés. Ceux-ci doivent être dans le même ordre que leurs paramètres respectifs dans la spécification de la méthode. Les paramètres peuvent être passés par valeur ou par référence.

Passer des paramètres par valeur signifie appeler une méthode avec un paramètre. Grâce à cela, la valeur de l'argument est transmise au paramètre.

Exemple

Le programme suivant montre un exemple de passage de paramètre par valeur. Les valeurs des arguments restent les mêmes même après l'invocation de la méthode.

Démo en direct

public class swappingExample {

   public static void main(String[] args) {
      int a = 30;
      int b = 45;
      System.out.println("Before swapping, a = " + a + " and b = " + b);

      // Invoke the swap method
      swapFunction(a, b);
      System.out.println("\n**Now, Before and After swapping values will be same here**:");
      System.out.println("After swapping, a = " + a + " and b is " + b);
   }

   public static void swapFunction(int a, int b) {
      System.out.println("Before swapping(Inside), a = " + a + " b = " + b);
      
      // Swap n1 with n2
      int c = a;
      a = b;
      b = c;
      System.out.println("After swapping(Inside), a = " + a + " b = " + b);
   }
}

Cela produira le résultat suivant −

Sortie

Before swapping, a = 30 and b = 45
Before swapping(Inside), a = 30 b = 45
After swapping(Inside), a = 45 b = 30

**Now, Before and After swapping values will be same here**:
After swapping, a = 30 and b is 45

Surcharge de méthode

Lorsqu'une classe a deux méthodes ou plus portant le même nom mais des paramètres différents, on parle de surcharge de méthode. C'est différent de l'écrasement. En surcharge, une méthode a le même nom de méthode, type, nombre de paramètres, etc.

Considérons l'exemple discuté précédemment pour trouver des nombres minimaux de type entier. Si, disons que nous voulons trouver le nombre minimum de type double. Ensuite, le concept de surcharge sera introduit pour créer deux méthodes ou plus avec le même nom mais des paramètres différents.

L'exemple suivant explique la même chose −

Exemple

Démo en direct

public class ExampleOverloading {

   public static void main(String[] args) {
      int a = 11;
      int b = 6;
      double c = 7.3;
      double d = 9.4;
      int result1 = minFunction(a, b);
      
      // same function name with different parameters
      double result2 = minFunction(c, d);
      System.out.println("Minimum Value = " + result1);
      System.out.println("Minimum Value = " + result2);
   }

   // for integer
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
   
   // for double
   public static double minFunction(double n1, double n2) {
     double min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

Cela produira le résultat suivant −

Sortie

Minimum Value = 6
Minimum Value = 7.3

La surcharge des méthodes rend le programme lisible. Ici, deux méthodes portent le même nom mais avec des paramètres différents. Le nombre minimum de types entier et double est le résultat.

Utilisation des arguments de ligne de commande

Parfois, vous souhaiterez transmettre des informations à un programme lorsque vous l'exécuterez. Ceci est accompli en passant des arguments de ligne de commande à main( ).

Un argument de ligne de commande est l'information qui suit directement le nom du programme sur la ligne de commande lorsqu'il est exécuté. Accéder aux arguments de la ligne de commande dans un programme Java est assez simple. Ils sont stockés sous forme de chaînes dans le tableau String passé à main().

Exemple

Le programme suivant affiche tous les arguments de ligne de commande avec lesquels il est appelé −

public class CommandLine {

   public static void main(String args[]) { 
      for(int i = 0; i<args.length; i++) {
         System.out.println("args[" + i + "]: " +  args[i]);
      }
   }
}

Essayez d'exécuter ce programme comme indiqué ici −

$java CommandLine this is a command line 200 -100

Cela produira le résultat suivant −

Sortie

args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100

Ce mot-clé

ceci est un mot clé en Java qui sert de référence à l'objet de la classe courante, avec dans une instance une méthode ou un constructeur. Utiliser ceci vous pouvez référencer les membres d'une classe tels que les constructeurs, les variables et les méthodes.

Remarque − Le mot clé ceci est utilisé uniquement dans les méthodes d'instance ou les constructeurs

En général, le mot-clé this sert à −

Différenciez les variables d'instance des variables locales si elles portent le même nom, au sein d'un constructeur ou d'une méthode.

class Student {
   int age;   
   Student(int age) {
      this.age = age;	
   }
}

Appelez un type de constructeur (constructeur paramétré ou par défaut) à partir d'un autre dans une classe. C'est ce qu'on appelle l'invocation explicite du constructeur.

class Student {
   int age
   Student() {
      this(20);
   }
   
   Student(int age) {
      this.age = age;	
   }
}

Exemple

Voici un exemple qui utilise ceci mot clé pour accéder aux membres d'une classe. Copiez et collez le programme suivant dans un fichier nommé This_Example.java .

Démo en direct

public class This_Example {
   // Instance variable num
   int num = 10;
	
   This_Example() {
      System.out.println("This is an example program on keyword this");	
   }

   This_Example(int num) {
      // Invoking the default constructor
      this();
      
      // Assigning the local variable num to the instance variable num
      this.num = num;	   
   }
   
   public void greet() {
      System.out.println("Hi Welcome to Tutorialspoint");
   }
      
   public void print() {
      // Local variable num
      int num = 20;
      
      // Printing the local variable
      System.out.println("value of local variable num is : "+num);
      
      // Printing the instance variable
      System.out.println("value of instance variable num is : "+this.num);
      
      // Invoking the greet method of a class
      this.greet();     
   }
   
   public static void main(String[] args) {
      // Instantiating the class
      This_Example obj1 = new This_Example();
      
      // Invoking the print method
      obj1.print();
	  
      // Passing a new value to the num variable through parametrized constructor
      This_Example obj2 = new This_Example(30);
      
      // Invoking the print method again
      obj2.print(); 
   }
}

Cela produira le résultat suivant −

Sortie

This is an example program on keyword this 
value of local variable num is : 20
value of instance variable num is : 10
Hi Welcome to Tutorialspoint
This is an example program on keyword this 
value of local variable num is : 20
value of instance variable num is : 30
Hi Welcome to Tutorialspoint

Arguments variables (var-args)

JDK 1.5 vous permet de passer un nombre variable d'arguments du même type à une méthode. Le paramètre dans la méthode est déclaré comme suit −

typeName... parameterName

Dans la déclaration de méthode, vous spécifiez le type suivi de points de suspension (...). Un seul paramètre de longueur variable peut être spécifié dans une méthode, et ce paramètre doit être le dernier paramètre. Tous les paramètres réguliers doivent le précéder.

Exemple

Démo en direct

public class VarargsDemo {

   public static void main(String args[]) {
      // Call method with variable args  
	   printMax(34, 3, 3, 2, 56.5);
      printMax(new double[]{1, 2, 3});
   }

   public static void printMax( double... numbers) {
      if (numbers.length == 0) {
         System.out.println("No argument passed");
         return;
      }

      double result = numbers[0];

      for (int i = 1; i <  numbers.length; i++)
      if (numbers[i] >  result)
      result = numbers[i];
      System.out.println("The max value is " + result);
   }
}

Cela produira le résultat suivant −

Sortie

The max value is 56.5
The max value is 3.0

La méthode finalize( )

Il est possible de définir une méthode qui sera appelée juste avant la destruction finale d'un objet par le ramasse-miettes. Cette méthode s'appelle finalize( ) , et il peut être utilisé pour s'assurer qu'un objet se termine proprement.

Par exemple, vous pouvez utiliser finalize( ) pour vous assurer qu'un fichier ouvert appartenant à cet objet est fermé.

Pour ajouter un finaliseur à une classe, il vous suffit de définir la méthode finalize( ). Le runtime Java appelle cette méthode chaque fois qu'il est sur le point de recycler un objet de cette classe.

Dans la méthode finalize( ), vous spécifierez les actions qui doivent être effectuées avant qu'un objet ne soit détruit.

La méthode finalize( ) a cette forme générale −

protected void finalize( ) {
   // finalization code here
}

Ici, le mot clé protected est un spécificateur qui empêche l'accès à finalize( ) par du code défini en dehors de sa classe.

Cela signifie que vous ne pouvez pas savoir quand ou même si finalize( ) sera exécuté. Par exemple, si votre programme se termine avant le nettoyage de la mémoire, finalize( ) ne s'exécutera pas.

Java - Expressions régulières Java - Fichiers et E/S

Java