# Méthodes en Java
Les méthodes en Java sont des blocs de code qui encapsulent des opérations spécifiques, permettant une structure modulaire et réutilisable du code, essentielle pour le développement backend et les architectures logicielles complexes.
Déclaration de méthodes
La syntaxe de base d’une méthode :
typeRetour nomMethode(typeParam1 param1, typeParam2 param2) {
// Corps de la méthode
return valeur; // si nécessaire
}Exemples simples:
public class ExemplesMethodes {
// Méthode sans paramètre et sans retour
public static void afficherBonjour() {
System.out.println("Bonjour!");
}
// Méthode avec paramètres et retour
public static int additionner(int a, int b) {
return a + b;
}
}Passage de paramètres
En Java, tout est passé par valeur. Pour les objets, on passe une copie de la référence, ce qui permet de modifier les données de l’objet mais pas la **variable d’origine.
1. Passage par valeur (types primitifs)
Exemple :
public class ExemplePrimitif {
public static void changer(int x) {
x = 99; // ne change PAS la variable d'origine
}
public static void main(String[] args) {
int a = 5;
changer(a);
System.out.println(a); // affiche 5
}
}Les primitifs ne peuvent pas être modifiés via une méthode.
2. Passage d’un objet (copie de la référence)
Exemple :
class Personne {
String nom;
Personne(String nom) {
this.nom = nom;
}
}
public class ExempleObjet {
public static void renommer(Personne p) {
p.nom = "Bob"; // modifie l'objet
}
public static void main(String[] args) {
Personne p1 = new Personne("Alice");
renommer(p1);
System.out.println(p1.nom); // affiche "Bob"
}
}Ici, on ne modifie pas la variable, mais l’objet pointé.
3. Réassignation d’une référence (ne marche pas)
Exemple pour montrer que p = ... ne change rien :
public class ExempleReassignation {
public static void changer(Personne p) {
p = new Personne("Charlie"); // ne change PAS p1
}
public static void main(String[] args) {
Personne p1 = new Personne("Alice");
changer(p1);
System.out.println(p1.nom); // affiche "Alice"
}
}Réassigner la référence ne modifie pas la variable d’origine.
4. Exemple simple avec tableau
public class ExempleTableau {
public static void doubler(int[] t) {
for (int i = 0; i < t.length; i++) {
t[i] *= 2;
}
}
public static void main(String[] args) {
int[] nums = {1, 2, 3};
doubler(nums);
// nums vaut maintenant {2, 4, 6}
}
int[] nombres = new Array[1, 6, 4, 12];
public static int somme(int... nombres)
}5. Exemple simple de méthode avec plusieurs paramètres
public static String saluer(String nom, int age) {
return nom + " a " + age + " ans.";
}
public static void main(String[] args) {
System.out.println(saluer("Alice", 20));
}
// Exemple avec un spread operator
public static double calculerMoyenne(double... notes) {
double somme = 0;
for (double note : notes) {
somme += note;
}
return somme / notes.length;
}Points clés à retenir
- Les types primitifs sont toujours passés par valeur
- Les objets sont passés par référence (techniquement, la référence est passée par valeur)
- Pour modifier des valeurs primitives, il faut :
- Soit retourner la nouvelle valeur
- Soit encapsuler la valeur dans un objet
- Soit utiliser un tableau
- Les tableaux et les objets peuvent être modifiés à l’intérieur des méthodes
- Une méthode peut avoir :
- Aucun paramètre
- Un ou plusieurs paramètres
- Un nombre variable de paramètres (varargs)
- Un type de retour ou void
Méthodes définies dans une classe
En Java, les méthodes de classe sont des fonctions définies dans une classe qui décrivent les comportements ou les actions que les objets de la classe peuvent effectuer. Ces méthodes peuvent manipuler les données de l’objet, effectuer des opérations et renvoyer des résultats. La compréhension des méthodes de classe est cruciale pour la mise en œuvre de la programmation orientée objet en Java.
Types de méthodes de classe
- Méthodes d’instance : Ces méthodes opèrent sur les instances d’une classe. Ils peuvent accéder directement aux variables d’instance et à d’autres méthodes d’instance.
- Méthodes statiques : Ces méthodes appartiennent à la classe et non à un objet particulier. Elles peuvent être appelées sans créer d’instance de la classe et ne peuvent accéder directement qu’aux variables statiques et autres méthodes statiques.
Syntaxe
Méthode d’instance
public returnType methodName(parameters) {
// method body
}Méthode statique
public static returnType methodName(parameters) {
// method body
}- returnType: Le type de données de la valeur renvoyée par la méthode. Utilisez
voidsi la méthode ne renvoie pas de valeur. - methodName: Le nom de la méthode, conformément aux conventions de nommage de Java.
- parameters: Une liste de paramètres d’entrée séparés par des virgules, chacun étant défini par un type de données et un nom.
Exemples
Méthode d’instance :
public class Car {
private String model;
public Car(String model) {
this.model = model;
}
public void displayModel() {
System.out.println("Car model: " + model);
}
public static void main(String[] args) {
Car car = new Car("Toyota");
car.displayModel();
}
}Dans cet exemple, displayModel() est une méthode d’instance qui imprime le modèle de la voiture. Elle est appelée sur une instance de la classe Car.
Méthode statique
public class MathUtils {
public static int add(int a, int b) {
return a + b;
}
public static void main(String[] args) {
int result = MathUtils.add(5, 3);
System.out.println("Sum: " + result);
}
}Ici, add() est une méthode statique qui additionne deux entiers. Elle est appelée en utilisant le nom de la classe MathUtils sans créer d’instance.
Surcharge de méthodes
public class Printer {
public void print(String text) {
System.out.println(text);
}
public void print(int number) {
System.out.println(number);
}
public static void main(String[] args) {
Printer printer = new Printer();
printer.print("Hello");
printer.print(100);
}
}Cet exemple illustre la surcharge de méthodes, où deux méthodes print() portent le même nom mais ont des types de paramètres différents.
Conseils et bonnes pratiques
Conventions d’appellation: Utilisez des noms descriptifs pour les méthodes afin d’indiquer leur objectif. Respectez les conventions d’appellation camelCase.
Surcharge des méthodes: Utilisez la surcharge des méthodes pour définir plusieurs méthodes portant le même nom mais avec des paramètres différents pour des opérations différentes.
Modificateurs d’accès: Utilisez les modificateurs d’accès appropriés (public, private, protected) pour contrôler la visibilité des méthodes.
Méthodes statiques: Utilisez des méthodes statiques pour les fonctions utilitaires ou d’assistance qui ne dépendent pas de variables d’instance.
Évitez les méthodes longues : Veillez à ce que les méthodes soient concises et centrées sur une seule tâche afin d’améliorer la lisibilité et la maintenabilité.
Documentation: Incluez des commentaires Javadoc pour décrire l’objectif et l’utilisation des méthodes, en particulier des API publiques.