Semaine 1 : JOUR 5 – Méthodes et modularité

Cours théorique

5.1 Introduction aux méthodes (fonctions)

Concept : en COBOL, vous avez PERFORM et paragraphes. En Java, les méthodes.

// SYNTAXE d'une méthode :
// modificateur typeRetour nomMethode(paramètres) {
//     corps de la méthode
//     return valeur;
// }

public class ExempleMethodes {
    // Méthode sans paramètre ni retour
    public static void afficherBonjour() {
        System.out.println("Bonjour !");
    }
    
    // Méthode avec paramètre, sans retour
    public static void afficherMessage(String message) {
        System.out.println("Message: " + message);
    }
    
    // Méthode avec paramètre et retour
    public static int doubler(int nombre) {
        return nombre * 2;
    }
    
    // Méthode avec plusieurs paramètres
    public static double calculerMoyenne(double a, double b, double c) {
        return (a + b + c) / 3.0;
    }
    
    public static void main(String[] args) {
        // Appels de méthodes
        afficherBonjour();
        afficherMessage("Formation Java");
        
        int resultat = doubler(5);
        System.out.println("5 x 2 = " + resultat);
        
        double moy = calculerMoyenne(12.5, 15.0, 14.5);
        System.out.println("Moyenne: " + moy);
    }
}

COMPARAISON COBOL :

PROCEDURE DIVISION.
MAIN-LOGIC.
    PERFORM AFFICHER-BONJOUR.
    PERFORM CALCULER-TOTAL.
    STOP RUN.

AFFICHER-BONJOUR.
    DISPLAY "Bonjour !".

CALCULER-TOTAL.
    COMPUTE TOTAL = MONTANT-1 + MONTANT-2.

Différences clés :

• Java : méthodes avec paramètres et valeur de retour
• COBOL : paragraphes, communication via WORKING-STORAGE

5.2 Passage de paramètres

Passage par valeur (types primitifs) :

public static void modifierNombre(int n) {
    n = n * 2;  // Modifie la COPIE locale
    System.out.println("Dans méthode: " + n);
}

public static void main(String[] args) {
    int nombre = 10;
    modifierNombre(nombre);
    System.out.println("Après appel: " + nombre);  // Toujours 10 !
}

// En COBOL : CALL BY CONTENT (même comportement)

Passage par référence (objets et tableaux) :

public static void modifierTableau(int[] tab) {
    tab[0] = 999;  // Modifie l'ORIGINAL
}

public static void main(String[] args) {
    int[] nombres = {1, 2, 3};
    modifierTableau(nombres);
    System.out.println(nombres[0]);  // 999 !
}

// En COBOL : CALL BY REFERENCE (même comportement)

5.3 Surcharge de méthodes (overloading)

NOUVEAU concept : plusieurs méthodes avec le même nom mais paramètres différents

public class Calculatrice {
    // Addition de 2 entiers
    public static int additionner(int a, int b) {
        return a + b;
    }
    
    // Addition de 3 entiers
    public static int additionner(int a, int b, int c) {
        return a + b + c;
    }
    
    // Addition de doubles
    public static double additionner(double a, double b) {
        return a + b;
    }
    
    public static void main(String[] args) {
        System.out.println(additionner(5, 3));           // Appelle version int, int
        System.out.println(additionner(5, 3, 2));        // Appelle version int, int, int
        System.out.println(additionner(5.5, 3.2));       // Appelle version double, double
    }
}

// Le compilateur choisit la bonne méthode selon les types des arguments
// IMPOSSIBLE en COBOL : chaque paragraphe a un nom unique

5.4 Portée (scope) et variables locales

public class ExemplePortee {
    // Variable de classe (globale à la classe)
    static int compteurGlobal = 0;
    
    public static void incrementer() {
        // Variable locale à la méthode
        int compteurLocal = 0;
        
        compteurGlobal++;  // Accessible
        compteurLocal++;   // Accessible uniquement ici
    }
    
    public static void afficher() {
        System.out.println(compteurGlobal);  // OK
        // System.out.println(compteurLocal);  // ERREUR : pas accessible !
    }
}

// En COBOL :
// WORKING-STORAGE : comme variables static
// LOCAL-STORAGE : comme variables locales (COBOL 2002+)

Travaux Pratiques (Après-midi - 4h)

TP5 : Méthodes et modularité

Exercice 1 : Conversion COBOL → Java - Paragraphes en méthodes (1h)

IDENTIFICATION DIVISION.
PROGRAM-ID. CALCUL-SALAIRE.

DATA DIVISION.
WORKING-STORAGE SECTION.
01 SALAIRE-BRUT PIC 9(7)V99.
01 TAUX-CHARGES PIC V99 VALUE 0.23.
01 SALAIRE-NET PIC 9(7)V99.
01 PRIME PIC 9(5)V99.

PROCEDURE DIVISION.
MAIN-PROGRAM.
    MOVE 3500.00 TO SALAIRE-BRUT.
    PERFORM CALCULER-PRIME.
    PERFORM CALCULER-SALAIRE-NET.
    PERFORM AFFICHER-RESULTAT.
    STOP RUN.

CALCULER-PRIME.
    IF SALAIRE-BRUT > 3000
        COMPUTE PRIME = SALAIRE-BRUT * 0.10
    ELSE
        MOVE ZERO TO PRIME
    END-IF.

CALCULER-SALAIRE-NET.
    COMPUTE SALAIRE-NET = SALAIRE-BRUT - (SALAIRE-BRUT * TAUX-CHARGES) + PRIME.

AFFICHER-RESULTAT.
    DISPLAY "Salaire brut: " SALAIRE-BRUT.
    DISPLAY "Prime: " PRIME.
    DISPLAY "Salaire net: " SALAIRE-NET.

Corrigé :

public class CalculSalaire {
    // Constante pour le taux de charges
    static final double TAUX_CHARGES = 0.23;
    
    /**
     * Calcule la prime en fonction du salaire brut
     * @param salaireBrut Le salaire brut
     * @return Le montant de la prime
     */
    public static double calculerPrime(double salaireBrut) {
        if (salaireBrut > 3000) {
            return salaireBrut * 0.10;
        } else {
            return 0.0;
        }
    }
    
    /**
     * Calcule le salaire net
     * @param salaireBrut Le salaire brut
     * @param prime La prime
     * @return Le salaire net
     */
    public static double calculerSalaireNet(double salaireBrut, double prime) {
        double charges = salaireBrut * TAUX_CHARGES;
        return salaireBrut - charges + prime;
    }
    
    /**
     * Affiche le résultat du calcul
     */
    public static void afficherResultat(double salaireBrut, double prime, double salaireNet) {
        System.out.println("=== CALCUL SALAIRE ===");
        System.out.printf("Salaire brut: %.2f EUR%n", salaireBrut);
        System.out.printf("Prime: %.2f EUR%n", prime);
        System.out.printf("Charges (%.0f%%): %.2f EUR%n", TAUX_CHARGES * 100, salaireBrut * TAUX_CHARGES);
        System.out.printf("Salaire net: %.2f EUR%n", salaireNet);
    }
    
    public static void main(String[] args) {
        // Données
        double salaireBrut = 3500.00;
        
        // Traitements (appels de méthodes)
        double prime = calculerPrime(salaireBrut);
        double salaireNet = calculerSalaireNet(salaireBrut, prime);
        
        // Affichage
        afficherResultat(salaireBrut, prime, salaireNet);
        
        // Test avec un autre salaire
        System.out.println();
        double autreSalaire = 2500.00;
        double autrePrime = calculerPrime(autreSalaire);
        double autreNet = calculerSalaireNet(autreSalaire, autrePrime);
        afficherResultat(autreSalaire, autrePrime, autreNet);
    }
}

Exercice 2 : Bibliothèque de méthodes utilitaires (1h)

Créer une classe avec des méthodes réutilisables.

Corrigé :

public class UtilitairesCalcul {
    /**
     * Calcule la TVA
     */
    public static double calculerTVA(double montantHT, double tauxTVA) {
        return montantHT * tauxTVA;
    }
    
    /**
     * Calcule le montant TTC
     */
    public static double calculerTTC(double montantHT, double tauxTVA) {
        return montantHT + calculerTVA(montantHT, tauxTVA);
    }
    
    /**
     * Calcule une remise
     */
    public static double appliquerRemise(double montant, double pourcentageRemise) {
        double remise = montant * (pourcentageRemise / 100.0);
        return montant - remise;
    }
    
    /**
     * Arrondit un montant à 2 décimales
     */
    public static double arrondir(double montant) {
        return Math.round(montant * 100.0) / 100.0;
    }
    
    /**
     * Vérifie si un montant est valide (positif et non nul)
     */
    public static boolean estMontantValide(double montant) {
        return montant > 0;
    }
    
    /**
     * Calcule un pourcentage
     */
    public static double calculerPourcentage(double partie, double total) {
        if (total == 0) {
            return 0;
        }
        return (partie / total) * 100.0;
    }
    
    // Programme de test
    public static void main(String[] args) {
        double montantHT = 100.0;
        double tauxTVA = 0.20;
        
        // Test des méthodes
        double tva = calculerTVA(montantHT, tauxTVA);
        double ttc = calculerTTC(montantHT, tauxTVA);
        
        System.out.println("Montant HT: " + montantHT);
        System.out.println("TVA (20%): " + tva);
        System.out.println("Montant TTC: " + ttc);
        
        // Avec remise
        double montantRemise = appliquerRemise(ttc, 10);
        System.out.println("Après remise 10%: " + arrondir(montantRemise));
        
        // Pourcentage
        double pourcentage = calculerPourcentage(tva, ttc);
        System.out.printf("TVA représente %.2f%% du TTC%n", pourcentage);
    }
}

Exercice 3 : Validation de données (1h)

Créer des méthodes de validation pour différents types de données.

Corrigé :

public class ValidateurDonnees {
    /**
     * Valide un code client (format: CLI-XXXX avec X = chiffre)
     */
    public static boolean validerCodeClient(String code) {
        if (code == null || code.length() != 8) {
            return false;
        }
        if (!code.startsWith("CLI-")) {
            return false;
        }
        String partie = code.substring(4);
        for (int i = 0; i < partie.length(); i++) {
            if (!Character.isDigit(partie.charAt(i))) {
                return false;
            }
        }
        return true;
    }
    
    /**
     * Valide un numéro de téléphone (10 chiffres)
     */
    public static boolean validerTelephone(String telephone) {
        if (telephone == null || telephone.length() != 10) {
            return false;
        }
        for (int i = 0; i < telephone.length(); i++) {
            if (!Character.isDigit(telephone.charAt(i))) {
                return false;
            }
        }
        return telephone.startsWith("0");
    }
    
    /**
     * Valide un email (simplifiée)
     */
    public static boolean validerEmail(String email) {
        if (email == null || email.isEmpty()) {
            return false;
        }
        int posArobase = email.indexOf('@');
        if (posArobase <= 0) {
            return false;
        }
        int posPoint = email.lastIndexOf('.');
        return posPoint > posArobase && posPoint < email.length() - 1;
    }
    
    /**
     * Valide un montant (positif, max 2 décimales)
     */
    public static boolean validerMontant(double montant) {
        if (montant <= 0) {
            return false;
        }
        // Vérifier max 2 décimales
        double arrondi = Math.round(montant * 100.0) / 100.0;
        return Math.abs(montant - arrondi) < 0.001;
    }
    
    /**
     * Valide une date (format AAAAMMJJ)
     */
    public static boolean validerDate(String date) {
        if (date == null || date.length() != 8) {
            return false;
        }
        
        try {
            int annee = Integer.parseInt(date.substring(0, 4));
            int mois = Integer.parseInt(date.substring(4, 6));
            int jour = Integer.parseInt(date.substring(6, 8));
            
            if (annee < 1900 || annee > 2100) return false;
            if (mois < 1 || mois > 12) return false;
            if (jour < 1 || jour > 31) return false;
            
            // Vérifications simplifiées des jours par mois
            if (mois == 2 && jour > 29) return false;
            if ((mois == 4 || mois == 6 || mois == 9 || mois == 11) && jour > 30) {
                return false;
            }
            
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }
    
    public static void main(String[] args) {
        // Tests de validation
        System.out.println("=== TESTS DE VALIDATION ===");
        
        // Codes clients
        testerValidation("Code CLI-1234", validerCodeClient("CLI-1234"), true);
        testerValidation("Code CLI-ABCD", validerCodeClient("CLI-ABCD"), false);
        testerValidation("Code CLIENT-1234", validerCodeClient("CLIENT-1234"), false);
        
        // Téléphones
        testerValidation("Tel 0612345678", validerTelephone("0612345678"), true);
        testerValidation("Tel 1612345678", validerTelephone("1612345678"), false);
        testerValidation("Tel 06123", validerTelephone("06123"), false);
        
        // Emails
        testerValidation("Email test@example.com", validerEmail("test@example.com"), true);
        testerValidation("Email testexample.com", validerEmail("testexample.com"), false);
        testerValidation("Email @example.com", validerEmail("@example.com"), false);
        
        // Montants
        testerValidation("Montant 125.50", validerMontant(125.50), true);
        testerValidation("Montant -10.00", validerMontant(-10.00), false);
        
        // Dates
        testerValidation("Date 20240315", validerDate("20240315"), true);
        testerValidation("Date 20241345", validerDate("20241345"), false);
    }
    
    static void testerValidation(String test, boolean resultat, boolean attendu) {
        String statut = (resultat == attendu) ? "✓" : "✗";
        System.out.println(statut + " " + test + ": " + resultat);
    }
}

Exercice 4 : Mini-projet - Calculatrice modulaire (1h)

Créer une calculatrice complète avec menu.

Corrigé :

import java.util.Scanner;

public class CalculatriceModulaire {
    // Opérations de base
    public static double additionner(double a, double b) {
        return a + b;
    }
    
    public static double soustraire(double a, double b) {
        return a - b;
    }
    
    public static double multiplier(double a, double b) {
        return a * b;
    }
    
    public static double diviser(double a, double b) {
        if (b == 0) {
            System.out.println("Erreur: division par zéro!");
            return 0;
        }
        return a / b;
    }
    
    // Opérations avancées
    public static double puissance(double base, int exposant) {
        double resultat = 1;
        for (int i = 0; i < exposant; i++) {
            resultat *= base;
        }
        return resultat;
    }
    
    public static double racineCarree(double nombre) {
        if (nombre < 0) {
            System.out.println("Erreur: racine d'un nombre négatif!");
            return 0;
        }
        return Math.sqrt(nombre);
    }
    
    public static double pourcentage(double nombre, double pourcent) {
        return (nombre * pourcent) / 100.0;
    }
    
    // Affichage du menu
    public static void afficherMenu() {
        System.out.println("\n=== CALCULATRICE ===");
        System.out.println("1. Addition");
        System.out.println("2. Soustraction");
        System.out.println("3. Multiplication");
        System.out.println("4. Division");
        System.out.println("5. Puissance");
        System.out.println("6. Racine carrée");
        System.out.println("7. Pourcentage");
        System.out.println("0. Quitter");
        System.out.print("Choix: ");
    }
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int choix;
        
        do {
            afficherMenu();
            choix = scanner.nextInt();
            
            if (choix == 0) {
                break;
            }
            
            double resultat = 0;
            double a, b;
            
            switch (choix) {
                case 1:
                    System.out.print("Premier nombre: ");
                    a = scanner.nextDouble();
                    System.out.print("Deuxième nombre: ");
                    b = scanner.nextDouble();
                    resultat = additionner(a, b);
                    System.out.println(a + " + " + b + " = " + resultat);
                    break;
                    
                case 2:
                    System.out.print("Premier nombre: ");
                    a = scanner.nextDouble();
                    System.out.print("Deuxième nombre: ");
                    b = scanner.nextDouble();
                    resultat = soustraire(a, b);
                    System.out.println(a + " - " + b + " = " + resultat);
                    break;
                    
                case 3:
                    System.out.print("Premier nombre: ");
                    a = scanner.nextDouble();
                    System.out.print("Deuxième nombre: ");
                    b = scanner.nextDouble();
                    resultat = multiplier(a, b);
                    System.out.println(a + " × " + b + " = " + resultat);
                    break;
                    
                case 4:
                    System.out.print("Dividende: ");
                    a = scanner.nextDouble();
                    System.out.print("Diviseur: ");
                    b = scanner.nextDouble();
                    resultat = diviser(a, b);
                    if (b != 0) {
                        System.out.println(a + " ÷ " + b + " = " + resultat);
                    }
                    break;
                    
                case 5:
                    System.out.print("Base: ");
                    a = scanner.nextDouble();
                    System.out.print("Exposant: ");
                    int exp = scanner.nextInt();
                    resultat = puissance(a, exp);
                    System.out.println(a + "^" + exp + " = " + resultat);
                    break;
                    
                case 6:
                    System.out.print("Nombre: ");
                    a = scanner.nextDouble();
                    resultat = racineCarree(a);
                    if (a >= 0) {
                        System.out.println("√" + a + " = " + resultat);
                    }
                    break;
                    
                case 7:
                    System.out.print("Nombre: ");
                    a = scanner.nextDouble();
                    System.out.print("Pourcentage: ");
                    b = scanner.nextDouble();
                    resultat = pourcentage(a, b);
                    System.out.println(b + "% de " + a + " = " + resultat);
                    break;
                    
                default:
                    System.out.println("Choix invalide!");
            }
            
        } while (choix != 0);
        
        System.out.println("Au revoir!");
        scanner.close();
    }
}