📝 Ce que vous apprendrez

• Qu'est-ce que le modèle des poids mouches ?
• Pourquoi et quand l'utiliser ?
• Comment l'implémenter en Java
• Analogies avec le monde réel
• Pièges courants et meilleures pratiques

🔍 Qu'est-ce que le modèle Flyweight ?

Le motif poids plume est utilisé pour minimiser l'utilisation de la mémoire en partageant autant de données que possible avec des objets similaires. Il s'agit de réutiliser les instances existantes au lieu d'en créer de nouvelles.

Pensez aux caractères dans un éditeur de texte : la lettre "a" apparaît des milliers de fois, mais nous n'avons pas besoin de milliers d'objets "a" distincts, seulement d'un objet partagé.

🧩 Quand l'utiliser ?

Appliquez le modèle du poids plume lorsque :

• Vous avez beaucoup d'objets qui consomment beaucoup de mémoire
• Beaucoup de ces objets sont similaires ou identiques
• Vous devez optimiser les performances et réduire l'empreinte mémoire.

🧱 Implémentation Java

🖼️ Étape 1 : Créer l'interface Flyweight

public interface Shape {
    void draw();
}

🔵 Étape 2 : Objets à poids mou en béton

public class Circle implements Shape {
    private String color;
    private int x;
    private int y;
    private int radius;

    public Circle(String color) {
        this.color = color;
    }

    public void setX(int x) {
        this.x = x;
    }

    public void setY(int y) {
        this.y = y;
    }

    public void setRadius(int radius) {
        this.radius = radius;
    }

    public void draw() {
        System.out.println("Drawing a " + color + " circle at (" + x + "," + y + ") with radius " + radius);
    }
}

🏭 Étape 3 : Fabrique de poids plume

import java.util.HashMap;

public class ShapeFactory {
    private static final HashMap<String, Shape> circleMap = new HashMap<>();

    public static Shape getCircle(String color) {
        Circle circle = (Circle) circleMap.get(color);

        if (circle == null) {
            circle = new Circle(color);
            circleMap.put(color, circle);
            System.out.println("Creating a " + color + " circle");
        }
        return circle;
    }
}

✅ Usage

public class FlyweightDemo {
    public static void main(String[] args) {
        for (int i = 0; i < 20; ++i) {
            Circle circle = (Circle) ShapeFactory.getCircle(getRandomColor());
            circle.setX(getRandomX());
            circle.setY(getRandomY());
            circle.setRadius(100);
            circle.draw();
        }
    }

    private static String getRandomColor() {
        String[] colors = {"Red", "Green", "Blue", "White", "Black"};
        return colors[(int) (Math.random() * colors.length)];
    }

    private static int getRandomX() {
        return (int) (Math.random() * 100);
    }

    private static int getRandomY() {
        return (int) (Math.random() * 100);
    }
}

🌐 Analogie avec le monde réel

• Les éditeurs de texte** réutilisent des objets pour chaque lettre tapée, ce qui permet d'éviter des millions d'instances d'objets répétées.
• Développement de jeux : les arbres, les rochers et les maisons partagent souvent des modèles et des textures pour économiser de la mémoire.

⚠️ Les pièges à éviter

• ❌ L'utilisation du poids plume là où il n'est pas nécessaire - il ne vaut pas toujours la peine d'ajouter de la complexité.
• ❌ Gestion inappropriée de l'état partagé et de l'état unique (distinguer soigneusement l'état intrinsèque de l'état extrinsèque)
• ❌ Rendre les objets Flyweight mutables alors qu'ils devraient être immuables

✅ Meilleures pratiques

• Conserver l'état partagé (intrinsèque) à l'intérieur de l'objet flyweight
• Transmettre l'état unique (extrinsèque) à l'extérieur en cas de besoin
• Documenter l'utilisation du poids plume afin d'éviter toute confusion ultérieure.

📘 Recap

• Le modèle Flyweight minimise l'utilisation de la mémoire en partageant des objets
• A utiliser de préférence lorsqu'il s'agit d'un grand nombre d'objets similaires
• Sépare l'état partagé de l'état unique.
• Exemples concrets : éditeurs de texte, moteurs graphiques, mise en commun d'objets.