Aller au contenu

JOUR 5 – STRUCTURATION DU CODE, MÉTHODES, TABLEAUX ET COLLECTIONS JAVA

Formation Java / Spring Boot pour développeurs COBOL

Objectifs pédagogiques

À l’issue de cette cinquième journée, vous serez être capable de :

Les analogies COBOL sont encore un peu présentes, mais commencent volontairement à s’estomper.

Mise en contexte (COBOL → Java)

En COBOL, un programme bien structuré repose sur :

Exemple classique COBOL :

PERFORM CALCUL-SOLDE
PERFORM CONTROLE-DECOUVERT
PERFORM AFFICHAGE-RESULTAT

En Java, on vise exactement le même objectif, mais avec :

Aujourd’hui, nous allons passer progressivement d’un programme monolithique à un programme structuré.

Cours

Première approche

J’ai conçu le cours de la manière suivante :

Java Partie 1 - Sans Cobol

Dans ce cours, on abordera les différentes collections et la notion d’interface :

On ne pourra pas encore approdondir les notions d’itérateur (Iterator) permettant de parcourir les collections. Nous les verrons ultérieurement.

Lien vers les notions de base pour comprendre les Tableaux et les méthodes

Lien vers l’utilisation de Arrays.copyOf() pour manipuler des tableaux

Lien vers les notions de base pour comprendre et manipuler des Collections

Java Partie 2 - avec un peu de Cobol

Structurer le code en méthodes

Nous pourrions nous poser la question de savoir si c’est une bonne pratique d’avoir écrit jusqu’à maintenant notre code dans la méthode main() !

Un programme Java écrit entièrement dans main() :

Objectifs d’un code structurer :

Définition d’une méthode Java

Syntaxe générale :

typeRetour nomMethode(type parametre1, type parametre2) {
    // instructions
    return valeur; // si typeRetour ≠ void
}

Premier exemple : la méthode reçoit 2 arguments en paramètres et retourne une valeur de type double.

public double crediter(double solde, double montant) {
    return solde += montant;
}

Second exemple : Même genre de méthode mais en utilisant des objets de type BigDecimal.

static BigDecimal calculerSolde(BigDecimal solde, BigDecimal operation) {
    return solde.add(operation);
}

Correspondance COBOL avec Java (paragraphes / méthodes)

En COBOL :

CALCUL-SOLDE.
    ADD OPERATION TO SOLDE.

En Java :

static BigDecimal calculerSolde(BigDecimal solde, BigDecimal operation) {
    return solde.add(operation);
}

Différences importantes :

Paramètres et valeurs de retour

Passage par valeur (rappel)

static void modifierValeur(int x) {
    x = 20;
}
...
// appel de la méthode depuis une autre méthode (on est dans le main())
int a = 10;
modifierValeur(a); // on ne sait pas ce que fait cette méthode de l'entier a
// a vaut toujours 10

Structuration progressive du traitement bancaire

Avant (code non structuré) dans une méthode main() :

BigDecimal solde = new BigDecimal("1000.00");

for (int i = 0; i < operations.length; i++) {
    solde = solde.add(operations[i]);
    if (solde.compareTo(BigDecimal.ZERO) < 0) {
        System.out.println("DECOUVERT");
    }
}
System.out.println(solde);

Après (code structuré) : On donne une responsabilité à chaque méthode

// le code est dans une méthode
static BigDecimal appliquerOperations(BigDecimal solde, BigDecimal[] operations) {
    for (int i = 0; i < operations.length; i++) {
        solde = solde.add(operations[i]);
    }
    return solde;
}

// cette autre méthode retourne un booléen pour dire si le compte est à découvert ou pas
static boolean estADecouvert(BigDecimal solde) {
    return solde.compareTo(BigDecimal.ZERO) < 0;
}

Les tableaux Java : rappels et limites

Déclaration :

BigDecimal[] operations = new BigDecimal[3];

Ou

BigDecimal[] operations = {
    new BigDecimal("-200.00"),
    new BigDecimal("150.00"),
    new BigDecimal("-50.00")
};

Limites des tableaux

En pratique, les tableaux sont rarement utilisés seuls dans les applications modernes.

Introduction aux collections Java

Pourquoi les collections existent ?

Les collections permettent :

List

Déclaration :

import java.util.ArrayList;
import java.util.List;

List<BigDecimal> operations = new ArrayList<>();

Ajouter des éléments :

operations.add(new BigDecimal("-200.00"));
operations.add(new BigDecimal("150.00"));
operations.add(new BigDecimal("-50.00"));

Parcourir la liste :

for (BigDecimal op : operations) {
    solde = solde.add(op);
}

Correspondance COBOL : OCCURS + index mais sans taille fixe.

Map : clé / valeur (fondamentale en banque)

Exemple métier : la clé est le numéro de compte et valeur le solde.

import java.util.HashMap;
import java.util.Map;

Map<String, BigDecimal> comptes = new HashMap<>();

Ajout :

comptes.put("FR001", new BigDecimal("1000.00"));
comptes.put("FR002", new BigDecimal("250.00"));

Accès :

BigDecimal solde = comptes.get("FR001");

Correspondance COBOL : table indexée ou fichier clé / valeur

Démonstrations guidées (exemples plus complexes)

Démo 1 – Traitement bancaire structuré avec méthodes + List

static BigDecimal calculerSoldeFinal(BigDecimal soldeInitial, List<BigDecimal> operations) {
    BigDecimal solde = soldeInitial;
    for (BigDecimal op : operations) {
        solde = solde.add(op);
    }
    return solde;
}

Démo 2 – Comptage crédits / débits avec méthodes

static int compterDebits(List<BigDecimal> operations) {
    int compteur = 0;
    for (BigDecimal op : operations) {
        if (op.compareTo(BigDecimal.ZERO) < 0) {
            compteur++;
        }
    }
    return compteur;
}

Démo 3 – Gestion multi-comptes avec Map

static void afficherSoldes(Map<String, BigDecimal> comptes) {
    for (String numero : comptes.keySet()) {
        System.out.println(numero + " -> " + comptes.get(numero));
    }
}

Travaux pratiques – JOUR 5

TP 1 – Refactorisation complète du traitement bancaire

Objectif : transformer un programme séquentiel en programme structuré

Consignes :

TP 2 – Passage tableau → List

Objectif : mesurer le gain de lisibilité

Consignes :

TP 3 – Gestion simplifiée de plusieurs comptes

Objectif : introduire une vision réaliste banque

Consignes : Créer une Map<String, BigDecimal> pour stocker plusieurs comptes

Corrigés détaillés

Corrigé TP 1 – Programme structuré

static BigDecimal calculerSoldeFinal(BigDecimal soldeInitial, List<BigDecimal> operations) {
    BigDecimal solde = soldeInitial;
    for (BigDecimal op : operations) {
        solde = solde.add(op);
    }
    return solde;
}

static boolean estADecouvert(BigDecimal solde) {
    return solde.compareTo(BigDecimal.ZERO) < 0;
}

Corrigé TP 2 – List

List<BigDecimal> operations = new ArrayList<>();
operations.add(new BigDecimal("-200.00"));
operations.add(new BigDecimal("150.00"));
operations.add(new BigDecimal("-50.00"));

Corrigé TP 3 – Map

Map<String, BigDecimal> comptes = new HashMap<>();
comptes.put("FR001", new BigDecimal("1000.00"));
comptes.put("FR002", new BigDecimal("250.00"));
comptes.put("FR003", new BigDecimal("500.00"));

Section spéciale – Erreurs fréquentes

Avancement du TP fil rouge bancaire (BankLite)

Aujourd’hui, vous avez :

Décision d’architecture progressive :

Synthèse de la journée

Vous savez maintenant :

Préparation du Jour 6

Le Jour 6 marquera une étape majeure :