Section courante

A propos

Section administrative du site

Méthodes

Une méthode est une fonction définie à l'intérieur d'une classe.

Elle décrit le comportement d'un objet et agit généralement sur ses attributs.

En POO, les méthodes sont le moyen principal d'interaction avec les objets.

Rôle fondamental des méthodes

Les méthodes permettent de :

Méthodes vs fonctions procédurales

Fonction Méthode
Indépendante Appartient à une classe
Travaille sur des paramètres Travaille sur un objet
Pas de notion d'état Accès aux attributs
Logique dispersée Logique encapsulée

Structure d'une méthode

Syntaxe générique :

modificateur typeRetour nomMethode(paramètres) {
   instructions;
   return valeur;
}

Signature d'une méthode

La signature comprend :

Le type de retour ne fait pas partie de la signature.

Méthodes d'instance

Les méthodes d'instance :

  1. class Compte {
  2.     double solde;
  3.  
  4.     void deposer(double montant) {
  5.         solde += montant;
  6.     }
  7. }

Méthodes de classe (statique)

  1. class MathUtils {
  2.     static int carre(int x) {
  3.         return x * x;
  4.     }
  5. }

Méthodes et encapsulation

Les méthodes sont la porte d'entrée contrôlée vers les attributs.

  1. private double solde;
  2.  
  3. public double getSolde() {
  4.     return solde;
  5. }

On n'expose jamais l'état brut.

Méthodes mutatrices vs accesseurs

Type Rôle
Getter Lire l'état
Setter Modifier l'état
Méthode métier Appliquer une règle

  1. void retirer(double montant) {
  2.     if (montant <= solde) solde -= montant;
  3. }

Méthodes avec paramètres

Passage par valeur / référence :

  1. void changerNom(Utilisateur u) {
  2.     u.setNom("Paul");
  3. }

Surcharge de méthodes (Overloading)

Plusieurs méthodes de même nom, signatures différentes.

  1. int addition(int a, int b);
  2. double addition(double a, double b);

Résolution à la compilation.

Redéfinition (Override)

Une sous-classe modifie le comportement hérité.

  1. class Chien extends Animal {
  2.     @Override
  3.     void crier() {
  4.         System.out.println("Ouaf");
  5.     }
  6. }

Résolution à l'exécution (polymorphisme).

Méthodes abstraites

Méthodes sans implémentation :

  1. abstract class Forme {
  2.     abstract double aire();
  3. }

Oblige les sous-classes à implémenter le comportement.

Méthodes finales

  1. final void calculer() {}

Visibilité des méthodes

Modificateur Accès
private Classe uniquement
protected Classe + héritage
public Partout

Méthodes et polymorphisme

  1. Animal a = new Chien();
  2. a.crier();

Méthodes et interfaces

  1. interface Payable {
  2.     void payer();
  3. }
  4.  
  5. class Carte implements Payable {
  6.     public void payer() {}
  7. }

Favorise la flexibilité.

Méthodes récursives

Une méthode peut s'appeler elle-même.

  1. int factorielle(int n) {
  2.     if (n == 0) return 1;
  3.     return n * factorielle(n - 1);
  4. }

Méthodes et exceptions

  1. void retirer(double montant) throws Exception {
  2.     if (montant > solde) {
  3.         throw new Exception("Solde insuffisant");
  4.     }
  5. }

Méthodes et SOLID

Bonnes pratiques

Exemple complet

  1. class CompteBancaire {
  2.     private double solde;
  3.  
  4.     public void deposer(double montant) {
  5.         if (montant > 0) solde += montant;
  6.     }
  7.  
  8.     public void retirer(double montant) {
  9.         if (montant <= solde) solde -= montant;
  10.     }
  11.  
  12.     public double getSolde() {
  13.         return solde;
  14.     }
  15. }

Méthodes et UML

  1. + deposer(montant: double) : void
  2. + retirer(montant: double) : void
  3. + getSolde() : double

Erreurs fréquentes

Conclusion

Les méthodes sont le cour comportemental des objets.

Elles définissent ce que l'objet sait faire, pas seulement ce qu'il contient.

Une bonne méthode raconte une action métier claire.



Dernière mise à jour : Jeudi, le 1er janvier 2026