Flyweight Pattern

• Enables efficient sharing and reuse of objects.
• Particularly useful when dealing with large numbers of similar objects.

When you have tons of objects, memory can get eaten up fast, and performance can take a hit. The Flyweight Pattern helps by sharing objects to save memory. It splits the state into intrinsic (shared) and extrinsic (unique) parts, so shared objects can be reused in different situations at the same time.

Use Case

• Game Development
• Networking Applications
• Text Editors

Participants

• Flyweight Interface: Declares methods that flyweight objects must implement.
• Concrete Flyweight: Implements the Flyweight interface and stores intrinsic state.
• Unshared Concrete Flyweight: Not all Flyweight subclasses need to be shared.
• Flyweight Factory: Creates and manages Flyweight objects, ensuring shared instances are used.
• Client: Maintains references to flyweights and computes or stores extrinsic state.

Code

// Flyweight interface
interface Shape {
    void draw(int x, int y);
}

// Concrete Flyweight
class Circle implements Shape {
    private String color; // Intrinsic state

    public Circle(String color) {
        this.color = color;
    }

    @Override
    public void draw(int x, int y) {
        System.out.println("Drawing " + color + " circle at (" + x + "," + y + ")");
    }
}

Circle class implemets Shape interface with intrinstic state color that is shared. The draw method uses this intrinsic state to darw the circle.

// Flyweight Factory
class ShapeFactory {
    private static final Map<String, Shape> circleMap = new HashMap<>();

    public static Shape getCircle(String color) {
        Circle circle = (Circle) circleMap.get(color);

        if (circle == null) {
            circle = new Circle(color);
            circleMap.put(color, circle);
            System.out.println("Created " + color + " circle.");
        }
        return circle;
    }
}

// Client
public class FlyweightPatternDemo {
    public static void main(String[] args) {
        Shape redCircle1 = ShapeFactory.getCircle("Red");
        redCircle1.draw(10, 10);

        Shape redCircle2 = ShapeFactory.getCircle("Red");
        redCircle2.draw(20, 20);

        Shape blueCircle = ShapeFactory.getCircle("Blue");
        blueCircle.draw(30, 30);
    }
}

Cons

One downside of the Flyweight Pattern is that the client (like our FlyweightPatternDemo class) has to handle the extrinsic state. This means the client needs to keep track of things like the coordinates where the circles are drawn. If you mess up managing this state, it can lead to bugs.