Java - Méthodes

Une méthode Java est un ensemble d'instructions regroupées pour effectuer une opération. Lorsque vous appelez le 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, à appeler 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 -

Syntax

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

Ici,

  • public static - modificateur

  • int - type de retour

  • methodName - nom de la méthode

  • a, b - paramètres formels

  • int a, int 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 illustrée dans la syntaxe suivante -

Syntax

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

La syntaxe indiquée ci-dessus comprend -

  • modifier - Il définit le type d'accès de la méthode et son utilisation est facultative.

  • returnType - La méthode peut renvoyer une valeur.

  • nameOfMethod- Ceci est le nom de la méthode. La signature de méthode se compose du nom de la méthode et de la liste des paramètres.

  • Parameter List- 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.

  • method body - Le corps de la méthode définit ce que la méthode fait avec les instructions.

Example

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

Appel de méthode

Pour utiliser une méthode, elle doit être appelée. Il existe deux manières d'appeler une méthode, c'est-à-dire que la méthode retourne une valeur ou ne renvoie rien (pas de valeur de retour).

Le processus d'appel de méthode est simple. Lorsqu'un programme appelle une méthode, le contrôle du programme est transféré vers la méthode appelée. Cette méthode appelée renvoie ensuite le contrôle à l'appelant dans deux conditions, lorsque -

  • l'instruction return est exécutée.
  • il atteint la méthode terminant l'accolade fermante.

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

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

La méthode retournant 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 -

Example

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 -

Output

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 void methodRankPoints . Cette méthode est une méthode void, qui ne renvoie aucune valeur. L'appel à une méthode void doit être une instruction ie methodRankPoints (255.7); . Il s'agit d'une instruction Java qui se termine par un point-virgule, comme illustré dans l'exemple suivant.

Example

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 -

Output

Rank:A1

Passer 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.

Example

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'appel de la méthode.

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 -

Output

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 du dépassement. En cas de substitution, une méthode a le même nom de méthode, le même type, le même nombre de paramètres, etc.

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

L'exemple suivant explique la même chose -

Example

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 -

Output

Minimum Value = 6
Minimum Value = 7.3

Les méthodes de surcharge rendent le programme lisible. Ici, deux méthodes sont données par le même nom mais avec des paramètres différents. Le nombre minimum des types entier et double est le résultat.

Utilisation d'arguments de ligne de commande

Parfois, vous voudrez transmettre certaines informations à un programme lorsque vous l'exécutez. 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 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 ().

Example

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 -

Output

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

Le mot-clé this

thisest un mot clé en Java qui est utilisé comme référence à l'objet de la classe courante, avec dans une méthode d'instance ou un constructeur. En utilisant cela, vous pouvez faire référence aux membres d'une classe tels que des constructeurs, des variables et des méthodes.

Note- Le mot - clé this n'est utilisé que dans les méthodes d'instance ou les constructeurs

En général, le mot - clé utilisé pour -

  • Différenciez les variables d'instance des variables locales si elles ont les mêmes noms, 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. Il est connu sous le nom d'invocation de constructeur explicite.

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

Example

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

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 -

Output

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 de variable (var-args)

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

typeName... parameterName

Dans la déclaration de méthode, vous spécifiez le type suivi d'une ellipse (...). 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. Tout paramètre régulier doit le précéder.

Example

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 -

Output

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 garbage collector. Cette méthode s'appellefinalize( ), et il peut être utilisé pour garantir 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, vous définissez simplement 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 un 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 garbage collection, finalize () ne s'exécutera pas.