Leçon 6 - Méthodes

P1 - Fondamentaux

Apprenez à créer et utiliser des méthodes pour organiser et réutiliser votre code.

Qu'est-ce qu'une méthode ?

Une méthode est un bloc de code qui accomplit une tâche spécifique. C'est comme une "boîte noire" qui reçoit des données (paramètres), effectue un traitement, et peut retourner un résultat.

Anatomie d'une méthode

Voici la structure de base d'une méthode :

// [Modificateur] [Type de retour] [Nom de la méthode]([Paramètres])
public int Additionner(int nombre1, int nombre2)
{
    int resultat = nombre1 + nombre2;
    return resultat;
}

Modificateur : public, private, static...
Type de retour : le type de donnée que la méthode renvoie (int, string, void...)
Nom : le nom de la méthode (commencer par une majuscule)
Paramètres : les données d'entrée (optionnel)
Corps : le code entre les accolades
return : renvoie une valeur (sauf si void)

Méthodes sans valeur de retour (void)

Certaines méthodes ne renvoient aucune valeur, elles utilisent le type void :

public void SaluerUtilisateur(string nom)
{
    Console.WriteLine($"Bonjour {nom}!");
    Console.WriteLine("Bienvenue dans notre application.");
}

public void AfficherSeparateur()
{
    Console.WriteLine("=".PadLeft(40, '='));
}

Méthodes avec valeur de retour

Ces méthodes calculent et renvoient une valeur :

public double CalculerAire(double longueur, double largeur)
{
    return longueur * largeur;
}

public bool EstPair(int nombre)
{
    return nombre % 2 == 0;
}

public string ObtenirJourSemaine(int numeroJour)
{
    switch (numeroJour)
    {
        case 1: return "Lundi";
        case 2: return "Mardi";
        case 3: return "Mercredi";
        case 4: return "Jeudi";
        case 5: return "Vendredi";
        case 6: return "Samedi";
        case 7: return "Dimanche";
        default: return "Jour invalide";
    }
}

Appeler une méthode

Pour utiliser une méthode, vous devez l'appeler avec les bons paramètres :

static void Main(string[] args)
{
    // Appel de méthode void (sans retour)
    SaluerUtilisateur("Alice");
    AfficherSeparateur();

    // Appel de méthodes avec retour
    double aire = CalculerAire(5.0, 3.0);
    Console.WriteLine($"Aire: {aire} m²");

    bool estPairResult = EstPair(8);
    Console.WriteLine($"8 est pair: {estPairResult}");

    string jour = ObtenirJourSemaine(3);
    Console.WriteLine($"Le jour 3 est: {jour}");
}

Paramètres optionnels

Vous pouvez définir des valeurs par défaut pour certains paramètres :

public void AfficherMessage(string message, string prefixe = "INFO", bool avecTimestamp = false)
{
    string sortie = $"[{prefixe}] {message}";

    if (avecTimestamp)
    {
        sortie = $"{DateTime.Now:HH:mm:ss} " + sortie;
    }

    Console.WriteLine(sortie);
}

// Différentes façons d'appeler la méthode
AfficherMessage("Application démarrée");                    // Utilise les valeurs par défaut
AfficherMessage("Erreur détectée", "ERREUR");               // Change le préfixe
AfficherMessage("Début du traitement", "DEBUG", true);     // Tous les paramètres

Surcharge de méthodes (Overloading)

Vous pouvez créer plusieurs méthodes avec le même nom mais des paramètres différents :

// Calculer l'aire d'un carré
public double CalculerAire(double cote)
{
    return cote * cote;
}

// Calculer l'aire d'un rectangle
public double CalculerAire(double longueur, double largeur)
{
    return longueur * largeur;
}

// Calculer l'aire d'un triangle
public double CalculerAire(double base_triangle, double hauteur, bool estTriangle)
{
    return (base_triangle * hauteur) / 2;
}

// Utilisation
double aireCarre = CalculerAire(5);                    // Carré 5x5
double aireRectangle = CalculerAire(6, 4);            // Rectangle 6x4
double aireTriangle = CalculerAire(8, 3, true);      // Triangle base=8, hauteur=3

Méthodes statiques

Les méthodes statiques appartiennent à la classe, pas à une instance particulière :

public class MathUtils
{
    public static int Max(int a, int b)
    {
        return (a > b) ? a : b;
    }

    public static double CalculerDistance(double x1, double y1, double x2, double y2)
    {
        double dx = x2 - x1;
        double dy = y2 - y1;
        return Math.Sqrt(dx * dx + dy * dy);
    }

    public static bool EstPremier(int nombre)
    {
        if (nombre < 2) return false;

        for (int i = 2; i <= Math.Sqrt(nombre); i++)
        {
            if (nombre % i == 0) return false;
        }

        return true;
    }
}

// Utilisation des méthodes statiques
int maximum = MathUtils.Max(10, 25);
double distance = MathUtils.CalculerDistance(0, 0, 3, 4);
bool estPremier = MathUtils.EstPremier(17);

Méthodes statiques vs méthodes d'instance :

Statique : Appelée sur la classe - MathUtils.Max(a, b)
Instance : Appelée sur un objet - monObjet.MaMethode()
Les méthodes statiques ne peuvent pas accéder aux membres d'instance

Bonnes pratiques

Nommage : Utilisez des verbes qui décrivent l'action (CalculerAire, AfficherMessage)
Une responsabilité : Chaque méthode ne doit faire qu'une seule chose
Taille : Gardez vos méthodes courtes et lisibles (< 20-30 lignes)
Paramètres : Évitez trop de paramètres (max 3-4)
Return early : Retournez tôt pour éviter l'imbrication

Exercice pratique

Exercice :

Créez un programme de gestion d'une calculatrice simple avec les fonctionnalités suivantes :

Une méthode pour chaque opération de base (+, -, *, /)
Une méthode pour afficher le menu
Une méthode pour valider les entrées
Une méthode pour calculer la puissance d'un nombre

Calculatrice complète avec méthodes organisées

using System;

namespace Calculatrice
{
    class Program
    {
        static void Main(string[] args)
        {
            bool continuer = true;

            AfficherBienvenue();

            while (continuer)
            {
                AfficherMenu();
                string choix = Console.ReadLine();

                switch (choix)
                {
                    case "1":
                        EffectuerOperation(Addition, "Addition");
                        break;
                    case "2":
                        EffectuerOperation(Soustraction, "Soustraction");
                        break;
                    case "3":
                        EffectuerOperation(Multiplication, "Multiplication");
                        break;
                    case "4":
                        EffectuerDivision();
                        break;
                    case "5":
                        EffectuerPuissance();
                        break;
                    case "0":
                        continuer = false;
                        Console.WriteLine("Merci d'avoir utilisé la calculatrice!");
                        break;
                    default:
                        Console.WriteLine("Choix invalide. Réessayez.");
                        break;
                }

                if (continuer)
                {
                    AttendreAppuiTouche();
                }
            }
        }

        static void AfficherBienvenue()
        {
            Console.WriteLine("╔═══════════════════════════════════════╗");
            Console.WriteLine("║         CALCULATRICE C#               ║");
            Console.WriteLine("║     Bienvenue dans votre outil       ║");
            Console.WriteLine("║          de calcul !                  ║");
            Console.WriteLine("╚═══════════════════════════════════════╝");
            Console.WriteLine();
        }

        static void AfficherMenu()
        {
            Console.WriteLine("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            Console.WriteLine("              MENU PRINCIPAL");
            Console.WriteLine("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            Console.WriteLine("1. Addition (+)");
            Console.WriteLine("2. Soustraction (-)");
            Console.WriteLine("3. Multiplication (×)");
            Console.WriteLine("4. Division (÷)");
            Console.WriteLine("5. Puissance (^)");
            Console.WriteLine("0. Quitter");
            Console.WriteLine("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            Console.Write("Votre choix : ");
        }

        static double DemanderNombre(string message)
        {
            while (true)
            {
                Console.Write(message);
                string saisie = Console.ReadLine();

                if (double.TryParse(saisie, out double nombre))
                {
                    return nombre;
                }

                Console.WriteLine("❌ Veuillez entrer un nombre valide.");
            }
        }

        static double Addition(double a, double b)
        {
            return a + b;
        }

        static double Soustraction(double a, double b)
        {
            return a - b;
        }

        static double Multiplication(double a, double b)
        {
            return a * b;
        }

        static double Division(double a, double b)
        {
            if (b == 0)
            {
                throw new DivideByZeroException("Division par zéro impossible!");
            }
            return a / b;
        }

        static double Puissance(double base_nombre, double exposant)
        {
            return Math.Pow(base_nombre, exposant);
        }

        static void EffectuerOperation(Func<double, double, double> operation, string nomOperation)
        {
            Console.WriteLine($"\n--- {nomOperation} ---");

            double nombre1 = DemandderNombre("Premier nombre : ");
            double nombre2 = DemandderNombre("Deuxième nombre : ");

            double resultat = operation(nombre1, nombre2);
            AfficherResultat(nombre1, nombre2, resultat, nomOperation);
        }

        static void EffectuerDivision()
        {
            Console.WriteLine("\n--- Division ---");

            double nombre1 = DemandderNombre("Dividende : ");
            double nombre2 = DemandderNombre("Diviseur : ");

            try
            {
                double resultat = Division(nombre1, nombre2);
                AfficherResultat(nombre1, nombre2, resultat, "Division");
            }
            catch (DivideByZeroException ex)
            {
                Console.WriteLine($"❌ Erreur : {ex.Message}");
            }
        }

        static void EffectuerPuissance()
        {
            Console.WriteLine("\n--- Puissance ---");

            double base_nombre = DemandderNombre("Base : ");
            double exposant = DemandderNombre("Exposant : ");

            double resultat = Puissance(base_nombre, exposant);

            Console.WriteLine($"✓ {base_nombre}^{exposant} = {resultat:F2}");
        }

        static void AfficherResultat(double a, double b, double resultat, string operation)
        {
            string symbole = ObtenirSymbole(operation);
            Console.WriteLine($"✓ {a} {symbole} {b} = {resultat:F2}");
        }

        static string ObtenirSymbole(string operation)
        {
            switch (operation.ToLower())
            {
                case "addition": return "+";
                case "soustraction": return "-";
                case "multiplication": return "×";
                case "division": return "÷";
                default: return "=";
            }
        }

        static void AttendreAppuiTouche()
        {
            Console.WriteLine("\nAppuyez sur une touche pour continuer...");
            Console.ReadKey();
            Console.Clear();
        }
    }
}

Points clés à retenir

Organisation : Les méthodes organisent votre code en blocs réutilisables
DRY : Don't Repeat Yourself - évitez la duplication de code
Paramètres : Permettent de personnaliser le comportement
Return : Les méthodes peuvent renvoyer une valeur ou être void
Surcharge : Plusieurs méthodes avec le même nom mais des paramètres différents
Static : Méthodes liées à la classe, pas à l'instance