Vous êtes ici :
Accueil Cours Programmations La Programmation Orientée Objet en Java Les méthodes

La Programmation Orientée Objet en Java : Les méthodes

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

Maintenant, vous apprendrez à créer vos propres méthodes avec ou sans valeurs de retour, invoquer une méthode avec ou sans paramètres, des méthodes de surcharge utilisant les mêmes noms et appliquer l'abstraction de méthode dans la conception du programme.

Création de méthode

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

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

Ici,

  • static public : est le modificateur.
  • int : est le type de retour
  • funcName : est le nom de la fonction
  • a, b : sont les paramètres formels
  • int a, int b : est la liste des paramètres

Les méthodes sont également appelées procédures ou fonctions:

  • Procédures: elles ne renvoient aucune valeur.
  • Fonctions: ils renvoient la valeur.

La définition de la méthode consiste en un en-tête de méthode et un corps de méthode. La même chose est illustrée ci-dessous:

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 il est facultatif d'utiliser.
  • returnType : la méthode peut ou ne pas renvoyer une valeur.
  • nameOfMethod : c'est le nom de la méthode. La signature de la méthode comprend le nom de la méthode et 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 des paramètres ou non.
  • Method body : le corps de la méthode définit ce que la méthode fait avec les énoncés.

Exemple:

Voici le code source de la méthode définie ci-dessus appelée minFunction( ). Cette méthode prend deux paramètres num1 et num2 et renvoie le minimum des deux nombres:

/** 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 d’une méthode

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 renvoie le contrôle à l'appelant dans deux conditions, lorsque:

  • La déclaration de retour est exécutée.
  • Atteint la méthode qui finit de fermer l'accolade.

Les méthodes qui renvoient sont considérées comme un appel à une déclaration. Considérons un exemple:

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

La valeur de retour de la méthode peut être comprise par l'exemple suivant:

int result = sum(6, 9);

Exemple:

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

 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 produirait le résultat suivant:

Minimum value = 6

Le mot-clé void

Le mot-clé void nous permet de créer des méthodes qui ne renvoient pas de valeur. Ici, dans l'exemple suivant, nous envisageons une Méthode de Méthode 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 indiqué ci-dessous.

Exemple:

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 produirait le résultat suivant:

Rank:A1

Passage des paramètres par valeur

Tout en travaillant dans le processus d'appel, les arguments doivent être passés. Ceux-ci devraient être dans le même ordre que leurs paramètres respectifs dans la spécification de la méthode. Les paramètres peuvent être transmis 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 identiques 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 produirait le résultat suivant:

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 par le même nom mais des paramètres différents, elle est connue sous le nom de surcharge de méthode. Il est différent de la priorité. En supprimant une méthode, le même nom de méthode, le type, le nombre de paramètres etc.

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

L'exemple ci-dessous explique la même chose:

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 produirait le résultat suivant:

Minimum Value = 6

Minimum Value = 7.3

 Les surcharges de méthodes rendent le programme lisible. Ici, deux méthodes ont le même nom mais avec des paramètres différents. Le nombre minimum d'entiers et de type double est le résultat.

Utilisation des arguments de ligne de commande

Parfois, vous voudrez transmettre des informations dans un programme lorsque vous l'exécutez. Ceci est réalisé en passant des arguments de ligne de commande à la fonction 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é. Pour accéder aux arguments de ligne de commande à l'intérieur d'un programme Java, il est assez facile. Ils sont stockés sous la forme de chaînes dans le groupe de chaînes transmises à main().

Exemple:

Le programme suivant affiche tous les arguments de ligne de commande auxquels 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 produirait le résultat suivant:

args[0]: this

args[1]: is

args[2]: a

args[3]: command

args[4]: line

args[5]: 200

args[6]: -100

 Les Constructeurs

Un constructeur initialise un objet lorsqu'il est créé. Il a le même nom que sa classe et est syntaxiquement similaire à une méthode. Cependant, les constructeurs n'ont aucun type de retour explicite.

En règle générale, vous utiliserez un constructeur pour donner des valeurs initiales aux variables d'instance définies par la classe ou pour effectuer toute autre procédure de démarrage requise pour créer un objet entièrement formé.

Toutes les classes ont des constructeurs, que vous définissiez un ou non, car Java fournit automatiquement un constructeur par défaut qui initialise toutes les variables des membres à zéro. Toutefois, une fois que vous avez défini votre propre constructeur, le constructeur par défaut n'est plus utilisé.

Exemple:

Voici un exemple simple qui utilise un constructeur:

//A simple constructor.
class MyClass {
   int x;
   //Following is the constructor
   MyClass(){
      x = 10;
   }
}

 Vous appelez le constructeur pour initialiser les objets comme suit:

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass();
      MyClass t2 = new MyClass();
      System.out.println(t1.x + " " + t2.x);
   }
}

Le plus souvent, vous aurez besoin d'un constructeur qui accepte un ou plusieurs paramètres. Les paramètres sont ajoutés à un constructeur de la même manière qu'ils sont ajoutés à une méthode, il suffit de les déclarer dans les parenthèses après le nom du constructeur.

Exemple:

Voici un exemple simple qui utilise un constructeur:

//A simple constructor.
class MyClass{
   int x;
   //Following is the constructor
   MyClass(int i ){
      x = i;
   }
}

Vous appelez le constructeur pour initialiser les objets comme suit:

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass( 10 );
      MyClass t2 = new MyClass( 20 );
      System.out.println(t1.x + " " + t2.x);
   }
}

 Cela produirait le résultat suivant:

10 20

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 d'un point 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 précéder.

Exemple:

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 produirait le résultat suivant:

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 collecteur d'ordures. Cette méthode s'appelle finalize( ), et elle peut être utilisée 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 finalisateur à une classe, vous définissez simplement la méthode finalize( ). Le temps d'exécution Java appelle cette méthode chaque fois qu'il s'apprête à recycler un objet de cette classe.

Dans la méthode finalize( ), vous spécifiez les actions qui doivent être exécuté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 à la fonction finaliser( ) par un code défini en dehors de sa classe.

Cela signifie que vous ne pouvez pas savoir quand ou même si finaliser( ) sera exécuté. Par exemple, si votre programme se termine avant la collecte des ordures, finalize( ) ne sera pas exécuté.




Vous êtes ici :
Accueil Cours Programmations La Programmation Orientée Objet en Java Les méthodes