L'un des modèles structurels vise à réduire l'utilisation de la mémoire en partageant autant de données que possible avec des objets similaires.
C'est particulièrement utile lorsqu'il s'agit d'un grand nombre d'objets similaires, où la création d'une nouvelle instance pour chaque objet serait coûteuse en termes de consommation de mémoire.
notions clés :
État intrinsèque : l'état partagé entre plusieurs objets est indépendant du contexte et reste le même pour les différents objets.
État extrinsèque : état unique à chaque objet et transmis par le client. Cet état peut varier et n'est pas stocké dans l'objet Flyweight

Principaux participants :

Flyweight : interface permettant à l'objet Flyweight de recevoir l'état extrinsèque et de l'utiliser.
ConcreteFlyweight : implémente le Flyweight et stocke l'état intrinsèque.
FlyweightFactory : Gère les objets Flyweight et assure le partage des interfaces, il renvoie un Flyweight existant s'il existe déjà.

Client (comme la classe Main) : conserve une référence à Flyweight et fournit un état extrinsèque lorsqu'il doit interagir avec l'objet Flyweight.

Prenons un exemple d'objet Flyweight de caractère
Supposons que nous ayons un éditeur de texte qui doit restituer une grande quantité de texte. Chaque personnage peut être représenté comme un objet, mais avoir un objet distinct pour chaque personnage gaspillerait beaucoup de mémoire. Au lieu de cela, nous pouvons utiliser Flyweights pour partager les objets de caractère qui représentent chaque lettre et stocker l'état extrinsèque comme la position ou le formatage à l'extérieur

Poids mouche

public interface Flyweight {
    public void display(int x, int y);//x, y are the extrinsic state of the Flyweight object
}

Poids volant en béton

public class CharacterFlyweight implements Flyweight {
    private char ch;
    public CharacterFlyweight(char c){
        this.ch  = c;
    }
    @Override
    public void display(int x ,int y){
        System.out.println("[drawing character: " this.ch " at co-ordinates:(" x "," y ")]");
    }

}

Usine de poids mouche

public class FlyweightFactory {
    private static HashMap flyweights = new HashMap();
    public static Flyweight getFlyweight(char c){
        Flyweight flyweight = flyweights.getOrDefault(c,null);
        if(null==flyweight){
            flyweight = new CharacterFlyweight(c);
            flyweights.put(c,flyweight);
        }
        return flyweight;
    }
}

Principal

public class Main {
    public static void main(String args[]){
        Flyweight flyweight1 = FlyweightFactory.getFlyweight('a');
        Flyweight flyweight2 = FlyweightFactory.getFlyweight('b');
        Flyweight flyweight3 = FlyweightFactory.getFlyweight('a');// will use the same object that is referenced by flyweight1

        flyweight1.display(1, 2);//'a' displayed at 1,2
        flyweight2.display(3, 4);//'b' displayed at 3,4
        flyweight3.display(5, 7); // 'a'(shared) displayed at 5,7
    }
}

Sortir:

[drawing character: a at co-ordinates:(1,2)]
[drawing character: b at co-ordinates:(3,4)]
[drawing character: a at co-ordinates:(5,7)]

Points clés

• Efficacité de la mémoire : réduit l'utilisation de la mémoire en partageant des objets, en particulier lorsque l'état intrinsèque est volumineux ou qu'il existe de nombreux objets.
• Amélioration des performances : en réduisant le nombre d'objets créés, cela peut améliorer les performances de l'application lors de la gestion d'un grand nombre d'objets.

Inconvénients
Complexité : le modèle peut ajouter de la complexité au code, en particulier dans la gestion séparée des états extrinsèques et intrinsèques.
Overhead : s'il y a peu d'objets à partager, le modèle Flyweight peut introduire une complexité inutile sans économiser de mémoire significative.