Clean Code en Java : principes et exemples pour débutants

Clean Code en Java : principes et exemples pour débutants

Chaque développeur, en commençant son parcours en Java, se retrouve tôt ou tard dans une situation : le code fonctionne, mais il est impossible de s'y retrouver une semaine plus tard. C'est le problème classique du code "sale". Le Clean Code (code propre) n'est pas simplement un terme à la mode, mais un ensemble de pratiques qui rendent votre programme compréhensible, facile à maintenir et à étendre. Dans cet article, nous allons analyser les principes de base du Clean Code en Java pour débutants avec des exemples concrets.

Pourquoi le code propre est-il important ?

Dans le développement réel, le code est lu beaucoup plus souvent qu'il n'est écrit. Vous reviendrez sur vos anciens projets, travaillerez en équipe ou transmettrez du code à des collègues. Un code mal écrit ralentit le développement, augmente le nombre de bogues et démotive. Le Clean Code fait gagner du temps et des nerfs. Analysons les principes clés.

1. Des noms clairs : dites ce que vous faites

Les noms des variables, méthodes et classes doivent répondre à la question "qu'est-ce que c'est ?" ou "que fait-il ?". N'économisez pas les caractères — utilisez des noms significatifs.

Mauvais exemple (noms peu clairs) :

int d; // elapsed time in days\nList<String> lst = new ArrayList<>();\npublic void prc() { ... }

Bon exemple (Clean Code) :

int elapsedTimeInDays;\nList<String> customerNames = new ArrayList<>();\npublic void processPayment() { ... }

Conseil : Évitez les noms d'une seule lettre (sauf pour les compteurs de boucles). Le nom doit révéler l'intention. Au lieu de list, utilisez activeUsers ou orderIds.

2. Petites fonctions : une tâche — une fonction

Les fonctions doivent faire une seule chose et bien la faire. Les longues méthodes sont difficiles à tester et à comprendre. Visez une longueur maximale de 20 à 30 lignes.

Mauvais exemple (la fonction fait tout) :

public void processOrder(Order order) {\n    // validation\n    if (order.getTotal() <= 0) {\n        throw new IllegalArgumentException("Invalid order");\n    }\n    // sauvegarde en base de données\n    saveToDatabase(order);\n    // envoi d'email\n    sendEmail(order.getCustomerEmail(), "Order confirmed");\n    // mise à jour du stock\n    updateInventory(order);\n}

Bon exemple (découpage en petites fonctions) :

public void processOrder(Order order) {\n    validateOrder(order);\n    saveOrder(order);\n    notifyCustomer(order);\n    updateStock(order);\n}\n\nprivate void validateOrder(Order order) {\n    if (order.getTotal() <= 0) {\n        throw new IllegalArgumentException("Invalid order total");\n    }\n}\n\nprivate void notifyCustomer(Order order) {\n    sendEmail(order.getCustomerEmail(), "Order confirmed");\n}

Maintenant, chaque fonction a une responsabilité claire. Le code est devenu auto-documenté.

3. Évitez la duplication : principe DRY

Le principe DRY (Don't Repeat Yourself) stipule : chaque élément de connaissance doit avoir une représentation unique dans le système. Si vous copiez du code, vous créez des problèmes de maintenance.

Mauvais exemple (duplication) :

public double calculateDiscountForRegularCustomer(double price) {\n    return price * 0.9; // 10% de réduction\n}\n\npublic double calculateDiscountForVipCustomer(double price) {\n    return price * 0.8; // 20% de réduction\n}

Bon exemple (généralisation) :

public double calculateDiscount(double price, CustomerType type) {\n    double discountRate = getDiscountRate(type);\n    return price * discountRate;\n}\n\nprivate double getDiscountRate(CustomerType type) {\n    switch (type) {\n        case REGULAR: return 0.9;\n        case VIP:     return 0.8;\n        default:      return 1.0;\n    }\n}

Maintenant, la modification de la logique de réduction se fait à un seul endroit.

4. Formatage et commentaires : propreté visuelle

Le code doit être ac