The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Flyweight

Next ►
►

Introduction to Flyweight Pattern

The Flyweight pattern is a structural design pattern that allows programs to support large numbers of objects efficiently by sharing common parts of the state between multiple objects instead of keeping all the data in each object. This pattern is particularly useful when dealing with a large number of similar objects that consume a lot of memory.

Key Concepts

  • Intrinsic State: The state that is shared among multiple objects. This state is stored in the Flyweight object.
  • Extrinsic State: The state that is unique to each object and is passed to the Flyweight object when needed.
  • Flyweight Factory: A factory that creates and manages Flyweight objects, ensuring that shared objects are reused.

When to Use Flyweight Pattern

  • When an application uses a large number of objects.
  • When the memory cost of creating a large number of objects is high.
  • When most of the object state can be made extrinsic.

Example Scenario

Consider a text editor where each character is an object. If the text document is large, creating an object for each character would consume a lot of memory. Instead, we can use the Flyweight pattern to share common character objects.

Implementation

Step-by-Step Explanation

  1. Define the Flyweight Interface: This interface declares methods that accept extrinsic state.
  2. Create Concrete Flyweight Class: This class implements the Flyweight interface and stores intrinsic state.
  3. Create Flyweight Factory: This class creates and manages Flyweight objects, ensuring that objects are shared.
  4. Client Code: The client code uses the Flyweight objects and passes extrinsic state to them.

Code Example

from typing import Dict

# Flyweight Interface
class Flyweight:
    def __init__(self, intrinsic_state: str):
        self.intrinsic_state = intrinsic_state

    def operation(self, extrinsic_state: str):
        pass

# Concrete Flyweight Class
class ConcreteFlyweight(Flyweight):
    def operation(self, extrinsic_state: str):
        print(f"Intrinsic State: {self.intrinsic_state}, Extrinsic State: {extrinsic_state}")

# Flyweight Factory
class FlyweightFactory:
    _flyweights: Dict[str, Flyweight] = {}

    @staticmethod
    def get_flyweight(key: str) -> Flyweight:
        if key not in FlyweightFactory._flyweights:
            FlyweightFactory._flyweights[key] = ConcreteFlyweight(key)
        return FlyweightFactory._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")

    print(f"flyweight1 is flyweight3: {flyweight1 is flyweight3}")

Explanation

  • Flyweight Interface: The Flyweight class defines the interface for flyweight objects.
  • Concrete Flyweight Class: The ConcreteFlyweight class implements the Flyweight interface and stores intrinsic state.
  • Flyweight Factory: The FlyweightFactory class manages the flyweight objects and ensures that objects are shared.
  • Client Code: The client code demonstrates the use of the Flyweight pattern by creating and using flyweight objects.

Output

Intrinsic State: A, Extrinsic State: First Call
Intrinsic State: B, Extrinsic State: Second Call
Intrinsic State: A, Extrinsic State: Third Call
flyweight1 is flyweight3: True

Practical Exercises

Exercise 1: Implementing Flyweight Pattern

Task: Implement the Flyweight pattern for a graphical application where different shapes (e.g., circles, squares) are drawn on the screen. Each shape has a color (intrinsic state) and a position (extrinsic state).

Solution:

from typing import Dict

# Flyweight Interface
class Shape:
    def __init__(self, color: str):
        self.color = color

    def draw(self, x: int, y: int):
        pass

# Concrete Flyweight Class
class Circle(Shape):
    def draw(self, x: int, y: int):
        print(f"Drawing Circle of color {self.color} at ({x}, {y})")

# Flyweight Factory
class ShapeFactory:
    _shapes: Dict[str, Shape] = {}

    @staticmethod
    def get_shape(color: str) -> Shape:
        if color not in ShapeFactory._shapes:
            ShapeFactory._shapes[color] = Circle(color)
        return ShapeFactory._shapes[color]

# Client Code
if __name__ == "__main__":
    factory = ShapeFactory()

    shape1 = factory.get_shape("Red")
    shape1.draw(10, 20)

    shape2 = factory.get_shape("Green")
    shape2.draw(30, 40)

    shape3 = factory.get_shape("Red")
    shape3.draw(50, 60)

    print(f"shape1 is shape3: {shape1 is shape3}")

Output

Drawing Circle of color Red at (10, 20)
Drawing Circle of color Green at (30, 40)
Drawing Circle of color Red at (50, 60)
shape1 is shape3: True

Exercise 2: Identifying Intrinsic and Extrinsic State

Task: Given a scenario where you need to manage a large number of tree objects in a forest simulation, identify the intrinsic and extrinsic states for the Flyweight pattern.

Solution:

  • Intrinsic State: Tree type, color, texture.
  • Extrinsic State: Position (x, y coordinates).

Common Mistakes and Tips

  • Mistake: Storing extrinsic state inside the Flyweight object.
    • Tip: Ensure that extrinsic state is passed to the Flyweight object during method calls.
  • Mistake: Not using a factory to manage Flyweight objects.
    • Tip: Always use a Flyweight Factory to manage the creation and sharing of Flyweight objects.

Conclusion

The Flyweight pattern is a powerful tool for optimizing memory usage in applications that require a large number of similar objects. By sharing common parts of the state and managing unique state externally, the Flyweight pattern helps reduce memory consumption and improve performance.

In the next section, we will explore the Proxy pattern, another structural design pattern that provides a surrogate or placeholder for another object to control access to it.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved