D

I
C
1
FLYWEIGHT
I
N
F
O PATTERN
POIDS MOUCHE

Pape Serigne GUEYE / Abou Bakr SECK

Introduction
Les design patterns sont un recueil de solutions de conception
pour un certain nombre de problèmes récurrents en
programmation orienté objet.

Les motifs ou patrons de conception sont classifiés selon 3

grandes familles : motifs de création , motifs de comportement
et motifs de structuration.

C’est ce dernier qui nous intéressera dans le cadre du flyweight

design pattern.
A quoi sert-il ? (½)
Le pattern poids mouche est utilisé pour :

● optimiser le nombre d’objets présents dans la mémoire

de votre application.
● réduire le poids mémoire des programmes utilisant un
grand nombre d’objets
● les périphériques mobiles ou les systèmes intégrés de
plus en plus .
A quoi sert-il ? (2/2)
Il faut prendre en en compte plusieurs facteurs avant
l’utilisation de cette méthode :

● Le nombre d’objets à créer doit être suffisant.

● La création d’objet est lourde en mémoire et prend du
temps.
● Les propriétés de l’objet peuvent être divisées en
propriétés intrinsèques et extrinsèques. Les
propriétés extrinsèques d’un objet doivent être
définies par le programme client.
Comment l’utiliser ? (1/4)
On peut expliquer le modèle du flyweight design pattern à l’aide du
diagramme suivant :
Comment l’utiliser ? (2/4)
● Client :
Gère une référence aux Poids Mouche.
Calcule ou mémorise l'état extrinsèque des Poids Mouche.

● Fabrique de poids mouche :

Crée et gère des objets PoidsMouche.
S'assure que les objets PoidsMouche sont convenablement
partagés. Si un client réclame un Poids Mouche, l'objet
FabriqueDePoidsMouche fournit une instance existante ou en crée
une s'il n'y en a pas.
Comment l’utiliser ? (3/4)

● Poids mouche :
Déclare une interface à travers laquelle les poids mouche peuvent
recevoir les états extrinsèques et agir sur eux.

● Poids mouche concret :

Implémente l'interface d'un poids mouche et stocke éventuellement
les états intrinsèques. Un objet PoidsMoucheConcret doit être
partageable. Tout état qu'il contient doit être intrinsèque.
Comment l’utiliser ? (4/4)
● Poids mouche concret non partagé :

Toutes les sous-classes de PoidsMouche ne sont pas

nécessairement partagées. L'interface PoidsMouche permet le

partage mais il ne l'impose pas. Il est courant pour des objets

PoidsMoucheConcretNonPartage d'avoir pour enfants des objets

PoidsMoucheConcret à certains niveaux de la structure d'objets

PoidsMouche.
Cas illustratif ? (1/6)
Dans cet exemple, nous allons procéder à l’affichage
d’une forêt (1 000 000 d’arbres) ! Chaque arbre sera
représenté par son propre objet avec un certain état
(coordonnées, texture, etc.). Même si le programme remplit
bien son rôle, il consomme naturellement énormément de
RAM.

La raison est simple : de trop nombreux objets Arbre

contiennent des données dupliquées (nom, texture,
couleur). Nous pouvons lui appliquer le poids mouche afin
de stocker ces valeurs dans des objets poids mouche
séparés (la classe TypeArbre). Plutôt que de stocker les
mêmes données des milliers de fois dans des objets Arbre,
nous allons référencer un objet poids mouche avec
certaines valeurs.
Cas illustratif ? (2/6)
trees/Tree.java: Contient un état
unique pour chaque arbre
Cas illustratif ? (3/6)
trees/TreeType.java: Contient un état
partagé entre plusieurs arbres
Cas illustratif ? (4/6)
trees/TreeFactory.java: Encapsule la
complexité de la création de poids
mouches
Cas illustratif ? (5/6)
forest/Forest.java: La forêt que
nous dessinons
Cas illustratif ? (6/6)
Demo.java: Code client
Conclusion
Le poids mouche n’a qu’une seule utilité : minimiser la
consommation de mémoire RAM.
Le poids mouche peut être reconnu par une méthode de
création qui renvoie des objets du cache plutôt que d’en
créer de nouveaux.