Aller au contenu principal

Module Java.6 – Méthodes

Objectif​

Maîtriser les méthodes Java : déclaration, paramètres, return, static, et overloading pour créer du code réutilisable et modulaire.

Théorie​

Déclaration de méthode​

Structure de base :

[modificateurs] typeRetour nomMethode([paramètres]) {
    // Code
    return valeur;  // Si typeRetour n'est pas void
}

Exemple simple :

public void saluer() {
    System.out.println("Bonjour !");
}

Méthode avec paramètres :

public void saluer(String nom) {
    System.out.println("Bonjour " + nom);
}

Méthode avec retour :

public int additionner(int a, int b) {
    return a + b;
}

Modificateurs​

Visibilité :

  • public : Accessible partout
  • private : Accessible seulement dans la classe
  • protected : Accessible dans la classe et enfants
  • (package) : Accessible dans le même package

Autres :

  • static : Méthode de classe
  • final : Ne peut pas être surchargée
  • abstract : Pas d'implémentation (dans classe abstraite)

static​

Les méthodes static appartiennent à la classe, pas à l'instance.

class Utils {
    public static int additionner(int a, int b) {
        return a + b;
    }
}

// Utilisation sans instance
int resultat = Utils.additionner(5, 3);

Caractéristiques :

  • Pas besoin d'instance pour appeler
  • Ne peut pas accéder aux variables d'instance
  • Peut accéder aux variables statiques

Exemple :

class Compteur {
    private static int count = 0;
    private int id;
    
    public Compteur() {
        id = ++count;  // Utilise la variable statique
    }
    
    public static int getCount() {
        return count;  // OK : variable statique
        // return id;  // Erreur : id est d'instance
    }
}

Paramètres​

Paramètres simples​

public void afficher(String nom, int age) {
    System.out.println(nom + " a " + age + " ans");
}

Varargs (paramètres variables)​

Depuis Java 5, permet de passer un nombre variable d'arguments.

public int additionner(int... nombres) {
    int somme = 0;
    for (int n : nombres) {
        somme += n;
    }
    return somme;
}

additionner(1, 2, 3);        // 6
additionner(1, 2, 3, 4, 5);  // 15

Important : Varargs doit être le dernier paramètre.

Passage par valeur​

Java passe toujours par valeur (copie).

public void modifier(int x) {
    x = 10;  // Modifie seulement la copie locale
}

int a = 5;
modifier(a);
System.out.println(a);  // 5 (inchangé)

Pour les objets : La référence est copiée, mais l'objet peut être modifié.

public void modifierObjet(Personne p) {
    p.setAge(30);  // Modifie l'objet original
    p = new Personne("Autre", 25);  // Ne modifie pas l'original
}

Return​

Retour simple :

public int calculer() {
    return 42;
}

Retour multiple (via objet) :

public class Resultat {
    private int valeur;
    private String message;
    
    // Getters, setters, constructeur
}

public Resultat calculer() {
    return new Resultat(42, "Succès");
}

Pas de return (void) :

public void afficher() {
    System.out.println("Test");
    // Pas de return nécessaire
}

Return prématuré :

public int trouver(int[] nombres, int valeur) {
    for (int n : nombres) {
        if (n == valeur) {
            return n;  // Sort immédiatement
        }
    }
    return -1;  // Non trouvé
}

Overloading (Surcharge)​

Plusieurs méthodes avec le même nom mais signatures différentes.

public int additionner(int a, int b) {
    return a + b;
}

public int additionner(int a, int b, int c) {
    return a + b + c;
}

public double additionner(double a, double b) {
    return a + b;
}

// Utilisation
additionner(5, 3);        // Appelle la première
additionner(5, 3, 2);     // Appelle la deuxième
additionner(5.0, 3.0);    // Appelle la troisième

Règles :

  • Nom identique
  • Paramètres différents (nombre ou types)
  • Type de retour peut être différent (mais pas seul critère)

Méthodes récursives​

Une méthode qui s'appelle elle-même.

Exemple : Factorielle

public int factorielle(int n) {
    if (n <= 1) {
        return 1;
    }
    return n * factorielle(n - 1);
}

Attention : Toujours avoir une condition d'arrêt.

Méthodes utilitaires​

Exemple de classe utilitaire :

public class MathUtils {
    private MathUtils() {}  // Empêche l'instanciation
    
    public static int max(int a, int b) {
        return a > b ? a : b;
    }
    
    public static int min(int a, int b) {
        return a < b ? a : b;
    }
    
    public static double moyenne(int... nombres) {
        if (nombres.length == 0) return 0;
        int somme = 0;
        for (int n : nombres) {
            somme += n;
        }
        return (double) somme / nombres.length;
    }
}

Exercice​

  1. Méthodes de base

    • Créez des méthodes avec différents types de retour
    • Testez avec différents paramètres
    • Utilisez return

  2. static

    • Créez des méthodes static
    • Comparez avec méthodes d'instance
    • Testez l'accès aux variables

  3. Overloading

    • Créez plusieurs méthodes avec le même nom
    • Testez avec différents paramètres
    • Comprenez la résolution

  4. Varargs

    • Créez des méthodes avec varargs
    • Testez avec différents nombres d'arguments
    • Utilisez dans des cas pratiques

  5. Récursion

    • Créez des méthodes récursives
    • Testez avec différents cas
    • Faites attention aux conditions d'arrêt

Quiz​

  1. Que signifie static pour une méthode ?

    • Ne peut pas être modifiée
    • Appartient à la classe, pas à l'instance
    • Est plus rapide

  2. Que sont les varargs ?

    • Paramètres optionnels
    • Paramètres variables (int...)
    • Paramètres par défaut

  3. Comment Java passe les paramètres ?

    • Par référence
    • Par valeur (toujours)
    • Par référence pour objets

  4. Qu'est-ce que l'overloading ?

    • Redéfinir une méthode
    • Plusieurs méthodes même nom, paramètres différents
    • Hériter d'une méthode

  5. Que fait return dans une méthode void ?

    • Retourne null
    • Sort de la méthode (optionnel)
    • Erreur

Mini défi​

Mission : Créer une bibliothèque de méthodes mathématiques

Créez une classe MathUtils avec des méthodes static :

Fonctions :

  1. Opérations de base (additionner, multiplier, etc.)
  2. Calculs avancés (puissance, racine, etc.)
  3. Statistiques (moyenne, max, min, etc.)
  4. Utilitaires (arrondir, formater, etc.)

Critères :

  • ✅ Toutes les méthodes static
  • ✅ Overloading approprié
  • ✅ Varargs où utile
  • ✅ Gestion d'erreurs
  • ✅ Documentation JavaDoc

Objectif : Maîtriser les méthodes, static, overloading et créer une bibliothèque réutilisable.

Validation : Vous pouvez passer au module suivant quand vous maîtrisez les méthodes, static, overloading et varargs.