Dans cet article, nous allons vous montrer comment appeler une méthode en Java. Une méthode en java est un ensemble d’instructions qui sont regroupées pour effectuer une opération. Vous pouvez passer des données, appelées paramètres, dans une méthode. Les méthodes sont également connues sous le nom de fonctions.
Chaque méthode a son propre nom. Lorsque ce nom est rencontré dans un programme, l’exécution du programme se branche sur le corps de cette méthode. Lorsque la méthode est terminée, l’exécution revient à la zone du code du programme à partir de laquelle elle a été appelée, et le programme continue sur la ligne de code suivante.
Lorsque vous appelez la méthode System.out.println(), par exemple, le système exécute en fait plusieurs instructions en arrière-plan qui est déjà stockée dans la bibliothèque, afin d’afficher un message sur la console.
Pourquoi utiliser des méthodes ? Pour réutiliser du code : définir le code une fois, et l’utiliser plusieurs fois. En fait, le mode modulaire permet à plusieurs programmeurs de travailler indépendamment sur des concepts séparés qui peuvent être assemblés plus tard pour créer le projet entier. L’utilisation des méthodes sera notre premier pas dans la direction de la programmation modulaire.
Vous allez maintenant apprendre à créer vos propres méthodes avec ou sans return valeurs, à invoquer une méthode avec ou sans paramètres et à appliquer l’abstraction de méthode dans la conception du programme.
Créer une méthode
Une méthode doit être déclarée au sein d’une classe. Elle est définie avec le nom de la méthode, suivi de parenthèses ().
La définition de la méthode se compose d’un en-tête de méthode et d’un corps de méthode.
Exemple:
public class MyClass { public static void myMethod() { // code to be executed }}
Explication du code:
-
public static: modificateur, il définit le type d’accès de la méthode -
myMethod(): nom de la méthode -
static: signifie que la méthode appartient à la classe MyClass et non à un objet de la classe MyClass. -
void: signifie que cette méthode n’a pas de valeur de retour.
Note : Le mot public avant le nom de la méthode signifie que la méthode elle-même peut être appelée de n’importe où, ce qui inclut d’autres classes, même de différents paquets (fichiers), tant que vous importez la classe. Il existe trois autres mots qui peuvent remplacer public. Ce sont protected et private. Si une méthode est protected, alors seule cette classe et les sous-classes (classes qui utilisent cette base pour se construire) peuvent appeler la méthode. Si une méthode est private, alors la méthode ne peut être appelée qu’à l’intérieur de la classe. Le dernier mot-clé n’est même pas un mot. C’est si vous n’aviez rien à la place de publicprotected, ou private. C’est ce qu’on appelle la valeur par défaut, ou package-private. Cela signifie que seules les classes du même paquet peuvent appeler la méthode. Si vous souhaitez voir plus d’exemples, vous pouvez lire cet article.
Comment appeler une méthode en Java
Pour appeler une méthode en Java, écrivez le nom de la méthode suivi de deux parenthèses () et d’un point-virgule;
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.
Dans l’exemple suivant, myMethod() est utilisé pour imprimer un texte (l’action), lorsqu’il est appelé:
MyClass.java
public class MyClass { static void myMethod() { System.out.println("You have called me! My name is: myMethod!"); } public static void main(String args) { myMethod(); }}
Sortie:
You have called me! My name is: myMethod!
Dans l’exemple ci-dessus si vous enlevez le mot-clé static, java se plaint que vous ne pouvez pas appeler une méthode depuis une fonction statique :
Si vous ne voulez pas utiliser static, vous pouvez uniquement appeler la méthode d’instance :
public class MyClass { void myMethod() { System.out.println("You have called me! My name is: myMethod!"); } public static void main(String args) { new MyClass().myMethod(); }}
Une méthode peut également être appelée plusieurs fois :
MyClass.java
public class MyClass { static void myMethod() { System.out.println("You have called me! My name is: myMethod!"); } public static void main(String args) { myMethod(); myMethod(); myMethod(); }}
Sortie:
You have called me! My name is: myMethod!You have called me! My name is: myMethod!You have called me! My name is: myMethod!
Paramètres des méthodes Java
3.1 Paramètres et arguments
Les informations peuvent être transmises aux méthodes en tant que paramètre. Les paramètres agissent comme des variables à l’intérieur de la méthode.
Les paramètres sont spécifiés après le nom de la méthode, à l’intérieur des parenthèses. Vous pouvez ajouter autant de paramètres que vous le souhaitez, il suffit de les séparer par une virgule.
L’exemple suivant comporte une méthode qui prend en paramètre un int appelé num. Lorsque la méthode est appelée, nous transmettons un nombre, qui est utilisé à l’intérieur de la méthode pour être multiplié par 2:
Exemple03
public class Math { static int multiplyBytwo(int number) { return number * 2; } public static void main(String args) { int result = multiplyBytwo(2); System.out.println("The output is: " + result); }}
Sortie:
The result of multiplication is: 4
3.2 Paramètres multiples
Vous pouvez avoir autant de paramètres que vous le souhaitez. Voyez l’exemple suivant:
Exemple04
public class Math { static int sum(int num1, int num2) { return num1 + num2; } public static void main(String args) { int result = sum(2,3); System.out.println("Sum of numbers is: " + result); }}
Output:
Sum of numbers is: 5
Note : lorsque vous travaillez avec plusieurs paramètres, l’appel de méthode doit avoir le même nombre d’arguments que de paramètres, et les arguments doivent être passés dans le même ordre.
Dans les exemples 03 et 04, nous avons passé les paramètres par valeur. En fait les valeurs des arguments restent les mêmes même après l’invocation de la méthode. Voyons un autre exemple, exemple05:
Swapp.java
public class Swapp { public static void swapFunction(int a, int b) { System.out.println("In swapFunction at the begining: a = " + a + " , b = " + b); // Swap n1 with n2 int c = a; a = b; b = c; System.out.println("In swapFunction at the end: a = " + a + " , b = " + b); } public static void main(String args) { int a = 10; int b = 20; System.out.println("Before swapping: a = " + a + " , 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 + " , b = " + b); }}
Output:
Before swapping: a = 10 , b = 20In swapFunction at the begining: a = 10 , b = 20In swapFunction at the end: a = 20 , b = 10**Now, Before and After swapping values will be same here**:After swapping: a = 10 , b = 20
Maintenant si nous passons un objet et modifions l’un de ses champs, les valeurs seront également modifiées, exemple06:
Student.java
public class Student { String firstName; String familyName; int age; public Student(){ } public Student(String firstName, String familyName){ this.firstName = firstName; this.familyName = familyName; } public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } public String getFamilyName() { return familyName; } public void setFamilyName(String familyName) { this.familyName = familyName; } public int getAge() { return age; } public void setAge(int age) { this.age = age; }}
Maintenant, nous créons une instance de la classe Student et nous initialisons ses champs par son constructeur, après quoi nous changerons la valeur du champ par sa méthode :
public class Main { public static void main(String args) { Student student = new Student("Jack", "Smith"); System.out.println("Student's name is set (Constructor): " + student.getFirstName()); student.setFirstName("John"); System.out.println("Student's name is set (Main): " + student.getFirstName()); }}
Sortie:
Student's name is set (Constructor): JackStudent's name is set (Main): John
Surcharge de méthodes
Lorsqu’une classe possède deux ou plusieurs méthodes du même nom mais avec des paramètres différents, on parle de surcharge de méthodes. Elle est différente de la surcharge. Dans la surcharge, 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 suivant, qui possède une méthode qui ajoute des nombres de type différent, exemple07:
Sum.java
public class Sum { static int sum(int x, int y) { return x + y; } static double sum(double x, double y) { return x + y; } public static void main(String args) { int int_sum = sum(10, 20); double double_sum = sum(10.5, 23.67); System.out.println("int: " + int_sum); System.out.println("double: " + double_sum); }}
Output:
int: 30double: 34.17
Note : plusieurs méthodes peuvent avoir le même nom tant que le nombre et/ou le type de paramètres sont différents.
Méthode Overriding
L’Overriding est une fonctionnalité qui permet à une sous-classe ou à une classe enfant de fournir une implémentation spécifique d’une méthode qui est déjà fournie par l’une de ses super-classes ou classes parents. Lorsqu’une méthode d’une sous-classe a le même nom, les mêmes paramètres ou la même signature et le même type de retour (ou sous-type) qu’une méthode de sa super-classe, alors on dit que la méthode de la sous-classe surcharge la méthode de la super-classe.
Si un objet d’une classe parent est utilisé pour invoquer la méthode, alors la version de la classe parent sera exécutée, mais si un objet de la sous-classe est utilisé pour invoquer la méthode, alors la version de la classe enfant sera exécutée. En d’autres termes, c’est le type de l’objet auquel on fait référence (et non le type de la variable de référence) qui détermine quelle version d’une méthode surchargée sera exécutée.
5.1 Règles pour la surcharge des méthodes Java
- La méthode doit avoir le même nom que dans la classe parent
- La méthode doit avoir le même paramètre que dans la classe parent.
- Il doit y avoir une relation IS-A (héritage).
Voyons un exemple, exemple08:
Human.java
public class Human { //Overridden method public void walk() { System.out.println("Human is walking"); }}
Maintenant nous étendons la Human classe et créons une sous-classe à partir de celle-ci:
HumanChild.java
public class HumanChild extends Human{ //Overriding method public void walk(){ System.out.println("Child is walking"); } public static void main( String args) { HumanChild obj = new HumanChild(); obj.walk(); }}
Comme vous le voyez, obj.walk(); appellera la version de la classe enfant de walk():
Sortie:
Child is walking
.