Flyweight

The Flyweight design pattern is a structural pattern that allows you to share common parts of objects to save memory. Instead of creating a large number of similar objects, you create a few shared objects (flyweights) and use them in multiple contexts.

Key Concepts

1. Flyweight: The shared object that can be used in multiple contexts.

2. Context: The environment in which the flyweight is used.

3. Flyweight Factory: Creates and manages flyweight objects.

UML Diagram

+-----------------+        +-----------------+
|  Client         | --->>  |  Flyweight      |
+-----------------+        +-----------------+
                                ^
                                |
                                |
+-----------------+        +-----------------+
| FlyweightFactory|------->| ConcreteFlyweight|
+-----------------+        +-----------------+

--- Java Example ---

 // Flyweight interface
 public interface Flyweight {
     void operation(String extrinsicState);
 }

 // Concrete Flyweight class
 public class ConcreteFlyweight implements Flyweight {
     private final String intrinsicState;

     public ConcreteFlyweight(String intrinsicState) {
         this.intrinsicState = intrinsicState;
     }

     @Override
     public void operation(String extrinsicState) {
         System.out.println("Intrinsic State = " + intrinsicState + ", Extrinsic State = " + extrinsicState);
     }
 }

 // Flyweight Factory class
 public class FlyweightFactory {
     private final Map<String, Flyweight> flyweights = new HashMap<>();

     public Flyweight getFlyweight(String key) {
         if (!flyweights.containsKey(key)) {
             flyweights.put(key, new ConcreteFlyweight(key));
         }
         return flyweights.get(key);
     }
 }

 // Client code
 public class Client {
     public static void main(String[] args) {
         FlyweightFactory factory = new FlyweightFactory();

         Flyweight flyweight1 = factory.getFlyweight("A");
         flyweight1.operation("First Call");

         Flyweight flyweight2 = factory.getFlyweight("B");
         flyweight2.operation("Second Call");

         Flyweight flyweight3 = factory.getFlyweight("A");
         flyweight3.operation("Third Call");
     }
 }

--- Python Example ---

 from typing import Dict, Protocol

 # Flyweight interface
 class Flyweight(Protocol):
     def operation(self, extrinsic_state: str) -> None:
         pass

 # Concrete Flyweight class
 class ConcreteFlyweight(Flyweight):
     def __init__(self, intrinsic_state: str) -> None:
         self._intrinsic_state = intrinsic_state

     def operation(self, extrinsic_state: str) -> None:
         print(f"Intrinsic State = {self._intrinsic_state}, Extrinsic State = {extrinsic_state}")

 # Flyweight Factory class
 class FlyweightFactory:
     def __init__(self) -> None:
         self._flyweights: Dict[str, Flyweight] = {}

     def get_flyweight(self, key: str) -> Flyweight:
         if key not in self._flyweights:
             self._flyweights[key] = ConcreteFlyweight(key)
         return self._flyweights[key]

 # Client code
 if __name__ == "__main__":
     factory = FlyweightFactory()

     flyweight1 = factory.get_flyweight("A")
     flyweight1.operation("First Call")

     flyweight2 = factory.get_flyweight("B")
     flyweight2.operation("Second Call")

     flyweight3 = factory.get_flyweight("A")
     flyweight3.operation("Third Call")