Module Java.11 – Bonnes pratiques

Objectif

Appliquer les bonnes pratiques Java : Clean Code, conventions de nommage, patterns simples, et organisation professionnelle du code.

Théorie

Clean Code

Noms clairs et descriptifs

// ❌ Mauvais
int d;
String s;
void calc() {}

// ✅ Bon
int nombreJours;
String nomUtilisateur;
void calculerMoyenne() {}

Méthodes courtes et focalisées

// ❌ Mauvais : fait trop de choses
public void traiterDonnees() {
    // Validation
    // Transformation
    // Sauvegarde
    // Envoi email
    // ...
}

// ✅ Bon : une responsabilité
public void validerDonnees() {}
public void transformerDonnees() {}
public void sauvegarderDonnees() {}

DRY (Don't Repeat Yourself)

// ❌ Répétition
public void afficherNom1() {
    System.out.println("Nom : " + nom);
}
public void afficherNom2() {
    System.out.println("Nom : " + nom);
}

// ✅ Réutilisable
public void afficherNom() {
    System.out.println("Nom : " + nom);
}

Commentaires utiles

// ❌ Mauvais : explique le "comment"
// Incrémente i de 1
i++;

// ✅ Bon : explique le "pourquoi"
// Réinitialise le compteur pour le prochain lot
i = 0;

Conventions Java

Nommage

• Classes : PascalCase (Personne, GestionnaireUtilisateurs)
• Méthodes/Variables : camelCase (calculerMoyenne, nomUtilisateur)
• Constantes : UPPER_SNAKE_CASE (MAX_SIZE, API_URL)
• Packages : lowercase (com.monprojet)

Structure

public class MaClasse {
    // 1. Constantes statiques
    private static final int MAX_SIZE = 100;
    
    // 2. Variables statiques
    private static int count = 0;
    
    // 3. Variables d'instance
    private String nom;
    private int age;
    
    // 4. Constructeurs
    public MaClasse(String nom) {
        this.nom = nom;
    }
    
    // 5. Méthodes (getters/setters puis autres)
    public String getNom() {
        return nom;
    }
    
    public void afficher() {
        // Code
    }
}

Patterns simples

Singleton

Une seule instance de la classe.

public class Configuration {
    private static Configuration instance;
    
    private Configuration() {}  // Constructeur privé
    
    public static Configuration getInstance() {
        if (instance == null) {
            instance = new Configuration();
        }
        return instance;
    }
}

// Utilisation
Configuration config = Configuration.getInstance();

Factory

Crée des objets sans exposer la logique de création.

public class PersonneFactory {
    public static Personne creerEtudiant(String nom, int age, String ecole) {
        return new Etudiant(nom, age, ecole);
    }
    
    public static Personne creerProfesseur(String nom, int age, String matiere) {
        return new Professeur(nom, age, matiere);
    }
}

Builder

Construit des objets complexes étape par étape.

public class PersonneBuilder {
    private String nom;
    private int age;
    private String ville;
    
    public PersonneBuilder nom(String nom) {
        this.nom = nom;
        return this;
    }
    
    public PersonneBuilder age(int age) {
        this.age = age;
        return this;
    }
    
    public Personne build() {
        return new Personne(nom, age, ville);
    }
}

// Utilisation
Personne p = new PersonneBuilder()
    .nom("Jean")
    .age(30)
    .build();

Documentation JavaDoc

/**
 * Classe représentant une personne
 * 
 * @author Jean Dupont
 * @version 1.0
 * @since 1.0
 */
public class Personne {
    /**
     * Nom de la personne
     */
    private String nom;
    
    /**
     * Constructeur
     * 
     * @param nom Le nom de la personne
     * @param age L'âge de la personne (doit être > 0)
     * @throws IllegalArgumentException Si age <= 0
     */
    public Personne(String nom, int age) {
        if (age <= 0) {
            throw new IllegalArgumentException("Age doit être > 0");
        }
        this.nom = nom;
        this.age = age;
    }
    
    /**
     * Obtient le nom de la personne
     * 
     * @return Le nom de la personne
     */
    public String getNom() {
        return nom;
    }
}

Génération :

javadoc -d docs src/com/monprojet/*.java

Organisation du code

Packages

Organiser par fonctionnalité :

com.monprojet
├── models/          # Modèles de données
├── services/        # Logique métier
├── controllers/     # Contrôleurs
├── utils/          # Utilitaires
└── exceptions/     # Exceptions personnalisées

Séparation des responsabilités

MVC (Model-View-Controller) :

• Model : Données et logique métier
• View : Affichage (console, GUI, etc.)
• Controller : Coordination entre Model et View

Exercice

1. Clean Code

   • Refactorisez du code existant
   • Améliorez les noms
   • Raccourcissez les méthodes

2. Conventions

   • Appliquez les conventions Java
   • Organisez vos classes
   • Respectez le nommage

3. Patterns

   • Implémentez Singleton
   • Créez une Factory
   • Utilisez Builder

4. Documentation

   • Ajoutez JavaDoc à vos classes
   • Générez la documentation
   • Vérifiez le résultat

5. Organisation

   • Organisez en packages
   • Séparez les responsabilités
   • Créez une structure MVC

Quiz

1. Quelle convention pour les classes ?

   • camelCase
   • PascalCase
   • UPPER_CASE

2. Que signifie DRY ?

   • Don't Repeat Yourself
   • Don't Repeat Yourself
   • Do Repeat Yourself

3. Qu'est-ce qu'un Singleton ?

   • Plusieurs instances
   • Une seule instance
   • Aucune instance

4. Que fait JavaDoc ?

   • Compile le code
   • Génère la documentation
   • Exécute les tests

5. Quelle structure pour MVC ?

   • Model-Value-Controller
   • Model-View-Controller
   • Method-View-Controller

Mini défi

Mission : Refactoriser un projet selon les bonnes pratiques

Prenez un projet Java existant et refactorisez-le :

Améliorations :

1. Clean Code (noms, méthodes courtes, DRY)
2. Conventions Java (nommage, structure)
3. Patterns (Singleton, Factory si approprié)
4. Documentation JavaDoc complète
5. Organisation en packages

Critères :

• ✅ Code propre et lisible
• ✅ Conventions respectées
• ✅ Documentation complète
• ✅ Structure professionnelle

Objectif : Appliquer toutes les bonnes pratiques pour créer du code professionnel.

---

Validation : Vous pouvez passer au module suivant quand votre code respecte les bonnes pratiques.