Clean Code en Java : principes et exemples pour les praticiens

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Clean Code en Java : principes et exemples pratiques

Chaque développeur Java rencontre tôt ou tard le problème du code « sale ». Des méthodes difficiles à lire, des noms de variables insignifiants, des nombres magiques et des classes gigantesques — tout cela ralentit le développement, augmente le nombre de bogues et démotive l'équipe. Le livre de Robert Martin « Clean Code » est devenu une bible pour ceux qui souhaitent écrire des logiciels de qualité. Dans cet article, nous allons analyser les principes clés du code propre en Java et montrer comment les appliquer en pratique avec des exemples concrets.

1. Nommage des variables, méthodes et classes

Un bon nom représente la moitié du succès. Le nom doit révéler l'intention du programmeur. Si vous devez lire le corps d'une méthode pour comprendre ce qu'elle fait, le nom est mal choisi.

Mauvais exemple :

int d; // elapsed time in daysList<Integer> lst = new ArrayList<>();public void proc(int a, int b) {    // ...}

Bon exemple :

int elapsedTimeInDays;List<Integer> customerIds = new ArrayList<>();public void calculateTotalPrice(double basePrice, double discount) {    // ...}

Règles de nommage :

Classes et interfaces — des noms (Customer, OrderProcessor, PaymentService).
Méthodes — des verbes ou des constructions verbales (saveCustomer, findById, isActive).
Variables — des noms significatifs reflétant la nature des données (userName, totalAmount).
Évitez les abréviations — écrivez fullName au lieu de fn, sinon dans un mois vous ne vous souviendrez plus vous-même de ce que signifie fn.

2. Petites méthodes et principe de responsabilité unique

Une méthode doit faire une seule chose et la faire bien. Si une méthode contient plus de 10 à 15 lignes de code ou a plusieurs niveaux d'imbrication — c'est un signal pour un refactoring.

Mauvais exemple (la méthode fait trop de choses) :

public void processOrder(Order order) {    // 1. Validation    if (order.getItems().isEmpty()) throw new IllegalArgumentException("Order is empty");    // 2. Calcul de la remise    double discount = 0;    if (order.getCustomer().isPremium()) discount = 0.1;    // 3. Calcul du prix total    double total = 0;    for (Item item : order.getItems()) {        total += item.getPrice() * item.getQuantity();    }    total = total * (1 - discount);    // 4. Sauvegarde en base de données    orderRepository.save(order);    // 5. Envoi d'email    emailService.sendConfirmation(order.getCustomer().getEmail());}

Bon exemple (division en petites méthodes) :

public void processOrder(Order order) {    validateOrder(order);    double discount = calculateDiscount(order.getCustomer());    double totalPrice = calculateTotalPrice(order, discount);    order.setTotalPrice(totalPrice);    orderRepository.save(order);    sendConfirmationEmail(order.getCustomer());}

private void validateOrder(Order order) {    if (order.getItems().isEmpty()) {        throw new IllegalArgumentException("Order cannot be empty");    }}

private double calculateDiscount(Customer customer) {    return customer.isPremium() ? 0.1 : 0.0;}

private double calculateTotalPrice(Order order, double discount) {    double subtotal = order.getItems().stream()            .mapToDouble(item -> item.getPrice() * item.getQuantity())            .sum();    return subtotal * (1 - discount);}

private void sendConfirmationEmail(Customer customer) {    emailService.sendConfirmation(customer.getEmail());}