![design1](photos/03_28_23.webp)
Mar 28th, 2023
The Flyweight Pattern is a structural design pattern that is used to minimize memory usage by sharing data between multiple similar objects. The pattern achieves this by separating the intrinsic and extrinsic state of an object. The intrinsic state is the part of the object that is common between multiple instances of the same type, while the extrinsic state is the part that varies between instances.
The Flyweight Pattern consists of two main components: the FlyweightFactory
and the Flyweight
objects. The FlyweightFactory is responsible for managing and creating Flyweight
objects, while the Flyweight
objects are the shared objects that store the intrinsic state.
Let's take an example of a drawing application that allows users to draw shapes on a canvas. The application allows users to draw circles, squares, and rectangles. Each shape has its own set of properties such as color, size, and position.
Without the Flyweight Pattern, the application would create a new object for each shape drawn on the canvas, resulting in a large memory usage. By using the Flyweight Pattern, we can create a single Shape
object for each shape type and share it between all instances of the same type.
The ShapeFactory
is the FlyweightFactory
in this example. It is responsible for creating and managing the Shape
objects. When a user requests to draw a shape, the ShapeFactory
checks if a Shape
object with the same intrinsic state already exists. If it does, the ShapeFactory
returns the existing object. If it doesn't, the ShapeFactory
creates a new Shape
object and adds it to its internal collection.
The Shape
objects are the Flyweight
objects in this example. They store the intrinsic state of the shapes such as color and size. The extrinsic state, which varies between instances, is stored in the draw()
method of the Shape
object. This method takes a Canvas
object as a parameter and draws the shape on the canvas at the specified position.
By using the Flyweight Pattern, we can reduce the memory usage of the application by sharing data between multiple similar objects. This results in a more efficient and scalable application.
In conclusion, the Flyweight Pattern is a powerful structural design pattern that allows us to minimize memory usage by sharing data between similar objects. By separating the intrinsic and extrinsic state of an object, we can create more efficient and scalable applications.