Semaine 1 : JOUR 3 – Opérateurs et structures de contrôle

Cours théorique (Matin - 3h)

3.1 Les opérateurs en Java

Opérateurs arithmétiques :

int a = 10, b = 3;

int addition = a + b;        // 13 (comme ADD en COBOL)
int soustraction = a - b;    // 7  (comme SUBTRACT en COBOL)
int multiplication = a * b;  // 30 (comme MULTIPLY en COBOL)
int division = a / b;        // 3  (division entière!)
int modulo = a % b;          // 1  (reste de la division)

// ATTENTION : division entière si les deux opérandes sont int
double divisionReelle = (double) a / b;  // 3.333...

// En COBOL :
// COMPUTE RESULTAT = A + B
// ADD A TO B
// DIVIDE A BY B GIVING RESULTAT

Opérateurs de comparaison :

int x = 5, y = 10;

boolean egal = (x == y);           // false (comme IF A = B en COBOL)
boolean different = (x != y);      // true  (comme IF A NOT = B)
boolean inferieur = (x < y);       // true  (comme IF A < B)
boolean inferieurEgal = (x <= y);  // true  (comme IF A NOT > B)
boolean superieur = (x > y);       // false (comme IF A > B)
boolean superieurEgal = (x >= y);  // false (comme IF A NOT < B)

// Pour les String : UTILISER .equals() PAS ==
String s1 = "test";
String s2 = "test";
boolean identique = s1.equals(s2);  // true
// s1 == s2 compare les références, pas le contenu !

Opérateurs logiques :

boolean a = true, b = false;

boolean et = a && b;     // false (comme AND en COBOL)
boolean ou = a || b;     // true  (comme OR en COBOL)
boolean non = !a;        // false (comme NOT en COBOL)

// Court-circuit : && et || évaluent de gauche à droite
// et s'arrêtent dès que le résultat est déterminé

Opérateurs d’incrémentation (NOUVEAUTÉ) :

int compteur = 0;

compteur++;      // Incrémente de 1 (post-incrémentation)
++compteur;      // Incrémente de 1 (pré-incrémentation)
compteur += 5;   // Ajoute 5 (équivaut à compteur = compteur + 5)
compteur -= 3;   // Soustrait 3
compteur *= 2;   // Multiplie par 2

// En COBOL :
// ADD 1 TO COMPTEUR
// ADD 5 TO COMPTEUR

3.2 Structure conditionnelle : if / else

Syntaxe de base :

if (condition) {
    // Instructions si condition vraie
} else if (autreCondition) {
    // Instructions si autreCondition vraie
} else {
    // Instructions si aucune condition vraie
}

// COMPARAISON COBOL :
// IF condition
//     instructions
// ELSE IF autre-condition
//     instructions
// ELSE
//     instructions
// END-IF

Exemple détaillé :

public class ExempleIf {
    public static void main(String[] args) {
        int age = 17;
        double solde = 250.0;
        
        // If simple
        if (age >= 18) {
            System.out.println("Majeur");
        } else {
            System.out.println("Mineur");
        }
        
        // If imbriqués
        if (age >= 18) {
            if (solde >= 100) {
                System.out.println("Compte majeur avec solde suffisant");
            } else {
                System.out.println("Compte majeur mais solde insuffisant");
            }
        } else {
            System.out.println("Compte mineur");
        }
        
        // Conditions multiples
        if (age >= 18 && solde >= 1000) {
            System.out.println("Éligible au crédit");
        } else if (age >= 18 && solde >= 100) {
            System.out.println("Compte standard");
        } else {
            System.out.println("Non éligible");
        }
    }
}

Opérateur ternaire (raccourci) :

// Syntaxe : condition ? valeurSiVrai : valeurSiFaux
int age = 20;
String statut = (age >= 18) ? "Majeur" : "Mineur";

// Équivaut à :
String statut;
if (age >= 18) {
    statut = "Majeur";
} else {
    statut = "Mineur";
}

3.3 Structure switch / case

int jour = 3;
String nomJour;

switch (jour) {
    case 1:
        nomJour = "Lundi";
        break;  // IMPORTANT : sans break, continue au case suivant
    case 2:
        nomJour = "Mardi";
        break;
    case 3:
        nomJour = "Mercredi";
        break;
    case 4:
        nomJour = "Jeudi";
        break;
    case 5:
        nomJour = "Vendredi";
        break;
    default:
        nomJour = "Weekend";
        break;
}

// COMPARAISON COBOL :
// EVALUATE JOUR
//     WHEN 1
//         MOVE "Lundi" TO NOM-JOUR
//     WHEN 2
//         MOVE "Mardi" TO NOM-JOUR
//     WHEN OTHER
//         MOVE "Autre" TO NOM-JOUR
// END-EVALUATE

Switch moderne (Java 14+) :

// Expression switch (plus concis, pas besoin de break)
String nomJour = switch (jour) {
    case 1 -> "Lundi";
    case 2 -> "Mardi";
    case 3 -> "Mercredi";
    case 4 -> "Jeudi";
    case 5 -> "Vendredi";
    default -> "Weekend";
};

3.4 Les boucles

Boucle for (compteur) :

// Syntaxe : for (initialisation; condition; incrémentation)
for (int i = 0; i < 10; i++) {
    System.out.println("Itération " + i);
}

// COMPARAISON COBOL :
// PERFORM VARYING I FROM 0 BY 1 UNTIL I >= 10
//     DISPLAY "Itération " I
// END-PERFORM

Boucle while (condition en début) :

int compteur = 0;
while (compteur < 5) {
    System.out.println("Compteur: " + compteur);
    compteur++;
}

// COMPARAISON COBOL :
// PERFORM UNTIL COMPTEUR >= 5
//     DISPLAY "Compteur: " COMPTEUR
//     ADD 1 TO COMPTEUR
// END-PERFORM

Boucle do-while (condition en fin) :

int compteur = 0;
do {
    System.out.println("Compteur: " + compteur);
    compteur++;
} while (compteur < 5);

// Exécute AU MOINS UNE FOIS le bloc

// COMPARAISON COBOL :
// PERFORM WITH TEST AFTER UNTIL COMPTEUR >= 5
//     DISPLAY "Compteur: " COMPTEUR
//     ADD 1 TO COMPTEUR
// END-PERFORM

Instructions de contrôle de boucle :

// break : sort de la boucle
for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;  // Sort de la boucle à i=5
    }
    System.out.println(i);  // Affiche 0,1,2,3,4
}

// continue : passe à l'itération suivante
for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue;  // Saute les nombres pairs
    }
    System.out.println(i);  // Affiche 1,3,5,7,9
}

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

TP3 : Structures de contrôle

Exercice 1 : Conversion COBOL → Java - Conditions (45min)

Convertir ce programme COBOL :

01 MONTANT PIC 9(7)V99.
01 FRAIS   PIC 9(5)V99.
01 CATEGORIE PIC X(10).

IF MONTANT < 1000 THEN
    COMPUTE FRAIS = MONTANT * 0.05
    MOVE "BRONZE" TO CATEGORIE
ELSE IF MONTANT < 5000 THEN
    COMPUTE FRAIS = MONTANT * 0.03
    MOVE "ARGENT" TO CATEGORIE
ELSE
    COMPUTE FRAIS = MONTANT * 0.01
    MOVE "OR" TO CATEGORIE
END-IF.

DISPLAY "Montant: " MONTANT.
DISPLAY "Frais: " FRAIS.
DISPLAY "Catégorie: " CATEGORIE.

Corrigé :

public class CalculFrais {
    public static void main(String[] args) {
        double montant = 3500.50;
        double frais;
        String categorie;
        
        if (montant < 1000) {
            frais = montant * 0.05;
            categorie = "BRONZE";
        } else if (montant < 5000) {
            frais = montant * 0.03;
            categorie = "ARGENT";
        } else {
            frais = montant * 0.01;
            categorie = "OR";
        }
        
        System.out.println("Montant: " + montant);
        System.out.println("Frais: " + frais);
        System.out.println("Catégorie: " + categorie);
        
        // Avec montant = 3500.50 :
        // Frais = 105.015
        // Catégorie = ARGENT
    }
}

Exercice 2 : Switch pour codes statut (45min)

Créer un programme qui traduit des codes statut numériques en libellés.

public class TraductionStatut {
    public static void main(String[] args) {
        int codeStatut = 2;
        String libelle;
        String action;
        
        // TODO :
        // Code 1 : "En attente" → "Aucune action"
        // Code 2 : "En cours" → "Suivi requis"
        // Code 3 : "Terminé" → "Archivage"
        // Code 4 : "Annulé" → "Notification client"
        // Autre : "Inconnu" → "Vérification manuelle"
    }
}

Corrigé :

public class TraductionStatut {
    public static void main(String[] args) {
        int codeStatut = 2;
        String libelle;
        String action;
        
        // Version switch classique
        switch (codeStatut) {
            case 1:
                libelle = "En attente";
                action = "Aucune action";
                break;
            case 2:
                libelle = "En cours";
                action = "Suivi requis";
                break;
            case 3:
                libelle = "Terminé";
                action = "Archivage";
                break;
            case 4:
                libelle = "Annulé";
                action = "Notification client";
                break;
            default:
                libelle = "Inconnu";
                action = "Vérification manuelle";
                break;
        }
        
        System.out.println("Statut: " + libelle);
        System.out.println("Action: " + action);
        
        // Version moderne (Java 14+)
        String libelleModerne = switch (codeStatut) {
            case 1 -> "En attente";
            case 2 -> "En cours";
            case 3 -> "Terminé";
            case 4 -> "Annulé";
            default -> "Inconnu";
        };
    }
}

Exercice 3 : Boucles - Calcul d’intérêts (1h)

Simuler le calcul d’intérêts composés sur plusieurs années.

public class CalculInterets {
    public static void main(String[] args) {
        // TODO :
        // Capital initial : 10000 EUR
        // Taux annuel : 3%
        // Durée : 5 ans
        // Afficher le capital à chaque année
    }
}

Corrigé :

public class CalculInterets {
    public static void main(String[] args) {
        double capitalInitial = 10000.0;
        double tauxAnnuel = 0.03;  // 3%
        int dureeAnnees = 5;
        
        double capital = capitalInitial;
        
        System.out.println("=== SIMULATION INTÉRÊTS COMPOSÉS ===");
        System.out.println("Capital initial: " + capitalInitial + " EUR");
        System.out.println("Taux: " + (tauxAnnuel * 100) + "%");
        System.out.println();
        
        // Boucle for classique
        for (int annee = 1; annee <= dureeAnnees; annee++) {
            capital = capital * (1 + tauxAnnuel);
            System.out.println("Année " + annee + ": " + 
                             String.format("%.2f", capital) + " EUR");
        }
        
        double gain = capital - capitalInitial;
        System.out.println();
        System.out.println("Gain total: " + String.format("%.2f", gain) + " EUR");
        
        // COMPARAISON COBOL :
        // PERFORM VARYING ANNEE FROM 1 BY 1 UNTIL ANNEE > 5
        //     COMPUTE CAPITAL = CAPITAL * (1 + TAUX-ANNUEL)
        //     DISPLAY "Année " ANNEE ": " CAPITAL
        // END-PERFORM
    }
}

Exercice 4 : Mini-projet - Validation de code (1h30)

Programme de validation de codes produit avec plusieurs règles.

Corrigé :

public class ValidationCodeProduit {
    public static void main(String[] args) {
        String codeProduit = "PRD-2024-A123";
        boolean estValide = true;
        String messageErreur = "";
        
        // Règle 1 : Longueur entre 10 et 20 caractères
        if (codeProduit.length() < 10 || codeProduit.length() > 20) {
            estValide = false;
            messageErreur = "Longueur invalide (doit être entre 10 et 20)";
        }
        
        // Règle 2 : Doit commencer par "PRD-"
        if (estValide && !codeProduit.startsWith("PRD-")) {
            estValide = false;
            messageErreur = "Doit commencer par 'PRD-'";
        }
        
        // Règle 3 : Contient une année valide (2020-2030)
        if (estValide) {
            String anneeStr = codeProduit.substring(4, 8);
            int annee = Integer.parseInt(anneeStr);
            if (annee < 2020 || annee > 2030) {
                estValide = false;
                messageErreur = "Année invalide (doit être entre 2020 et 2030)";
            }
        }
        
        // Règle 4 : Catégorie valide (A, B, C)
        if (estValide) {
            char categorie = codeProduit.charAt(9);
            if (categorie != 'A' && categorie != 'B' && categorie != 'C') {
                estValide = false;
                messageErreur = "Catégorie invalide (doit être A, B ou C)";
            }
        }
        
        // Affichage résultat
        System.out.println("Code produit: " + codeProduit);
        if (estValide) {
            System.out.println("✓ CODE VALIDE");
            
            // Extraction des informations
            String annee = codeProduit.substring(4, 8);
            char categorie = codeProduit.charAt(9);
            String numero = codeProduit.substring(10);
            
            System.out.println("  Année: " + annee);
            System.out.println("  Catégorie: " + categorie);
            System.out.println("  Numéro: " + numero);
        } else {
            System.out.println("✗ CODE INVALIDE");
            System.out.println("  Erreur: " + messageErreur);
        }
    }
}