{"title":"Flyweight Design Pattern","description":null,"content":"\n> **DEFINITION**\n>\n> The **Flyweight Design Pattern** is a **structural pattern** that focuses on **efficiently sharing common parts of object state** across many objects to **reduce memory usage** and **boost performance**.\n\n\nIt’s particularly useful in situations where:\n\n- You need to create a **large number of similar objects**, but most of their data is **shared or repeated**.\n- Storing all object data individually would result in high memory consumption.\n- You want to **separate intrinsic state** (shared, reusable data) from **extrinsic state** (context-specific, passed in at runtime).\n\nLet’s walk through a real-world example to see how we can apply the Flyweight Pattern to drastically reduce memory usage and create scalable object-heavy systems.\n\n---\n\n# 1. The Problem: Rendering Characters\n\nImagine you're building a **rich text editor** that needs to render characters on screen, something like Google Docs or MS Word.\n\nEvery single character (`a`, `b`, `c`, `...`, `z`, punctuation, etc.) on screen needs to be rendered with formatting properties such as: font family, font size, color.\n\nOn top of that, each character has a position on the page (its x and y coordinates).\n\nThe straightforward approach is to create a full object for every character, bundling all this data together. Here is what the naive code looks like:\n\n\n```java\nclass CharacterGlyph {\n private char symbol; // e.g., 'a', 'b', etc.\n private String fontFamily; // e.g., \"Arial\"\n private int fontSize; // e.g., 12\n private String color; // e.g., \"#000000\"\n private int x; // position X\n private int y; // position Y\n\n public CharacterGlyph(char symbol, String fontFamily, int fontSize, String color, int x, int y) {\n this.symbol = symbol;\n this.fontFamily = fontFamily;\n this.fontSize = fontSize;\n this.color = color;\n this.x = x;\n this.y = y;\n }\n\n public void draw() {\n System.out.println(\"Drawing '\" + symbol + \"' in \" + fontFamily +\n \", size \" + fontSize + \", color \" + color + \" at (\" + x + \",\" + y + \")\");\n }\n}\n```\n\n```python\nclass CharacterGlyph:\n def __init__(self, symbol, font_family, font_size, color, x, y):\n self.symbol = symbol\n self.font_family = font_family\n self.font_size = font_size\n self.color = color\n self.x = x\n self.y = y\n \n def draw(self):\n print(f\"Drawing '{self.symbol}' in {self.font_family}, \"\n f\"size {self.font_size}, color {self.color} at ({self.x},{self.y})\")\n```\n\n```cpp\nclass CharacterGlyph {\nprivate:\n char symbol;\n string fontFamily;\n int fontSize;\n string color;\n int x;\n int y;\n\npublic:\n CharacterGlyph(char symbol, const string& fontFamily, int fontSize, const string& color, int x, int y)\n : symbol(symbol), fontFamily(fontFamily), fontSize(fontSize), color(color), x(x), y(y) {}\n\n void draw() {\n cout << \"Drawing '\" << symbol << \"' in \" << fontFamily \n << \", size \" << fontSize << \", color \" << color \n << \" at (\" << x << \",\" << y << \")\" << endl;\n }\n};\n```\n\n```go\ntype CharacterGlyph struct {\n\tsymbol rune // e.g., 'a', 'b', etc.\n\tfontFamily string // e.g., \"Arial\"\n\tfontSize int // e.g., 12\n\tcolor string // e.g., \"#000000\"\n\tx int // position X\n\ty int // position Y\n}\n\nfunc NewCharacterGlyph(symbol rune, fontFamily string, fontSize int, color string, x int, y int) *CharacterGlyph {\n\treturn &CharacterGlyph{\n\t\tsymbol: symbol,\n\t\tfontFamily: fontFamily,\n\t\tfontSize: fontSize,\n\t\tcolor: color,\n\t\tx: x,\n\t\ty: y,\n\t}\n}\n\nfunc (c *CharacterGlyph) Draw() {\n\tfmt.Println(\"Drawing '\", string(c.symbol), \"' in \", c.fontFamily,\n\t\t\", size \", c.fontSize, \", color \", c.color, \" at (\", c.x, \",\", c.y, \")\", sep=\"\")\n}\n```\n\n```csharp\nclass CharacterGlyph\n{\n private char symbol;\n private string fontFamily;\n private int fontSize;\n private string color;\n private int x;\n private int y;\n\n public CharacterGlyph(char symbol, string fontFamily, int fontSize, string color, int x, int y)\n {\n this.symbol = symbol;\n this.fontFamily = fontFamily;\n this.fontSize = fontSize;\n this.color = color;\n this.x = x;\n this.y = y;\n }\n\n public void Draw()\n {\n Console.WriteLine($\"Drawing '{symbol}' in {fontFamily}, size {fontSize}, color {color} at ({x},{y})\");\n }\n}\n```\n\n```typescript\nclass CharacterGlyph {\n private symbol: string; // e.g., 'a', 'b', etc.\n private fontFamily: string; // e.g., \"Arial\"\n private fontSize: number; // e.g., 12\n private color: string; // e.g., \"#000000\"\n private x: number; // position X\n private y: number; // position Y\n\n constructor(symbol: string, fontFamily: string, fontSize: number, color: string, x: number, y: number) {\n this.symbol = symbol;\n this.fontFamily = fontFamily;\n this.fontSize = fontSize;\n this.color = color;\n this.x = x;\n this.y = y;\n }\n\n draw(): void {\n console.log(\"Drawing '\" + this.symbol + \"' in \" + this.fontFamily +\n \", size \" + this.fontSize + \", color \" + this.color + \" at (\" + this.x + \",\" + this.y + \")\");\n }\n}\n```\n\n\nNow imagine rendering a 10-page document with 500,000 characters. Even if the vast majority of those characters share the same font, size, and color, you are still allocating half a million objects, each carrying its own copy of the formatting data. That is a lot of redundant memory.\n\n### Why This Is a Problem?\n\nThe naive design works for small documents. But as the character count grows, several serious problems surface.\n\n#### 1. High Memory Usage\n\nEvery character object stores its own copy of font family, font size, and color. In a typical document, most characters share identical formatting. If each object consumes roughly 100 bytes of formatting data, a 500,000-character document wastes approximately 50MB on duplicated information. \n\nThe actual character symbol and position might only need 12 bytes per instance. The rest is pure redundancy.\n\n#### 2. Performance Bottleneck\n\nCreating and managing 500,000 individual objects puts enormous pressure on the garbage collector (or memory allocator in non-GC languages). Each object occupies space on the heap. The GC has to track, scan, and potentially collect all of them. \n\nCPU cache performance also degrades because the working set is far larger than it needs to be. On lower-end devices, this can cause visible lag during scrolling and rendering.\n\n#### 3. Poor Scalability\n\nA single 10-page document is just the beginning. What about a user who opens five documents simultaneously? Or an e-book reader rendering a 600-page novel? \n\nMemory usage multiplies with every additional document, and the system runs out of headroom fast. What seemed acceptable for a small prototype becomes unworkable at real-world scale.\n\n#### 4. No State Separation\n\nThe core issue is that intrinsic state and extrinsic state are tangled together in every object. Intrinsic state (font family, font size, color) is shared across many characters. Extrinsic state (x and y position) is unique to each character. \n\nBy lumping them into the same object, we make every character instance unique even when only the position differs. There is no mechanism to share what can be shared.\n\n### What We Really Need\n\nWe need a way to:\n\n- Share formatting data (font, size, color) among all characters that use the same style\n- Store only truly unique data (position) for each character instance\n- Avoid duplicating redundant data while still rendering every character accurately\n- Use a central factory to manage and cache shared instances\n\nThis is exactly what the **Flyweight pattern** solves.\n\n---\n\n# 2. What is the Flyweight Pattern\n\nThe Flyweight pattern is a structural design pattern that minimizes memory usage by sharing common state across a large number of similar objects instead of storing that state in each object individually.\n\nTwo characteristics define the Flyweight pattern and set it apart from other structural patterns:\n\n1. **Intrinsic/extrinsic state separation.** The pattern divides object state into two parts. Intrinsic state is shared and immutable, stored inside the flyweight. Extrinsic state is context-dependent and unique, stored outside the flyweight and passed in when needed. This separation is what makes sharing possible.\n2. **Factory-managed caching.** A dedicated factory object controls the creation and reuse of flyweights. Clients never instantiate flyweights directly. They go through the factory, which maintains a cache and ensures that identical flyweights are shared rather than duplicated.\n\n---\n\n## Class Diagram\n\n\n\n\n#### **Flyweight Interface**\n\nDeclares a method like `draw(x, y)` that takes extrinsic state (position)\n\n#### **ConcreteFlyweight**\n\nImplements the flyweight and stores **intrinsic state** like font and symbol\n\n#### **FlyweightFactory**\n\nCaches and reuses flyweights to avoid duplication\n\n#### **Client**\n\nMaintains extrinsic state and uses shared flyweights to perform operations\n\n---\n\n# 3. Implementing Flyweight Pattern\n\nLet’s implement the **Flyweight Pattern** to optimize how we render text in a document editor. Our goal is to **share common formatting properties** (font, size, color) across characters and store only unique data (like position) at the instance level.\n\nThe fix is to split each character into two parts: the formatting data that can be shared (intrinsic state) and the position that is unique to each occurrence (extrinsic state). A factory manages the shared objects, and the client combines them with position data at render time.\n\n\n```mermaid\nclassDiagram\n class CharacterFlyweight {\n <>\n +draw(x, y)\n }\n\n class CharacterGlyph {\n -symbol: char\n -fontFamily: String\n -fontSize: int\n -color: String\n +draw(x, y)\n }\n\n class CharacterFlyweightFactory {\n -flyweightMap: Map\n +getFlyweight(symbol, font, size, color)\n +getFlyweightCount() int\n }\n\n class RenderedCharacter {\n -flyweight: CharacterFlyweight\n -x: int\n -y: int\n +render()\n }\n\n class TextEditorClient {\n -factory: CharacterFlyweightFactory\n -document: List~RenderedCharacter~\n +addCharacter(c, x, y, font, size, color)\n +renderDocument()\n }\n\n CharacterFlyweight <|.. CharacterGlyph\n CharacterFlyweightFactory --> CharacterFlyweight : creates/caches\n TextEditorClient --> CharacterFlyweightFactory : uses\n TextEditorClient --> RenderedCharacter : manages\n RenderedCharacter --> CharacterFlyweight : references\n\n style CharacterFlyweight fill:#69db7c,stroke:#000,color:#000\n style CharacterGlyph fill:#00ceff,stroke:#000,color:#000\n style CharacterFlyweightFactory fill:#38d9a9,stroke:#000,color:#000\n style RenderedCharacter fill:#ffa94d,stroke:#000,color:#000\n style TextEditorClient fill:#ffa94d,stroke:#000,color:#000\n```\n\n\n### Step 1: Define the Flyweight Interface\n\nThe flyweight interface declares a single method, `draw(x, y)`, where x and y represent extrinsic state. The flyweight itself does not store position. Instead, the caller passes position in at render time. This is the key design decision that makes sharing possible.\n\n\n```java\ninterface CharacterFlyweight {\n void draw(int x, int y);\n}\n```\n\n```python\nfrom abc import ABC, abstractmethod\n\nclass CharacterFlyweight(ABC):\n @abstractmethod\n def draw(self, x: int, y: int):\n pass\n```\n\n```cpp\nclass CharacterFlyweight {\npublic:\n virtual ~CharacterFlyweight() {}\n virtual void draw(int x, int y) = 0;\n};\n```\n\n```go\ntype CharacterFlyweight interface {\n\tdraw(x, y int)\n}\n```\n\n```csharp\ninterface ICharacterFlyweight\n{\n void Draw(int x, int y);\n}\n```\n\n```typescript\ninterface CharacterFlyweight {\n draw(x: number, y: number): void;\n}\n```\n\n\nEvery flyweight object will implement this interface. The client can call `draw` with any position, and the flyweight combines that position with its own stored formatting data to produce the output. This clean separation is what enables a single flyweight instance to serve thousands of characters.\n\n### Step 2: Implement the Concrete Flyweight\n\nThe concrete flyweight stores intrinsic state only: the character symbol, font family, font size, and color. These fields are immutable. Once a flyweight is created, its internal state never changes. The `draw` method combines the stored intrinsic state with the extrinsic position parameters to render the character.\n\n\n```java\nclass CharacterGlyph implements CharacterFlyweight {\n private final char symbol;\n private final String fontFamily;\n private final int fontSize;\n private final String color;\n\n public CharacterGlyph(char symbol, String fontFamily, int fontSize, String color) {\n this.symbol = symbol;\n this.fontFamily = fontFamily;\n this.fontSize = fontSize;\n this.color = color;\n }\n\n @Override\n public void draw(int x, int y) {\n System.out.println(\"Drawing '\" + symbol + \"' [Font: \" + fontFamily +\n \", Size: \" + fontSize + \", Color: \" + color + \"] at (\" + x + \",\" + y + \")\");\n }\n}\n```\n\n```python\nclass CharacterGlyph(CharacterFlyweight):\n def __init__(self, symbol, font_family, font_size, color):\n self.symbol = symbol\n self.font_family = font_family\n self.font_size = font_size\n self.color = color\n \n def draw(self, x, y):\n print(f\"Drawing '{self.symbol}' [Font: {self.font_family}, \"\n f\"Size: {self.font_size}, Color: {self.color}] at ({x},{y})\")\n```\n\n```cpp\nclass CharacterGlyph : public CharacterFlyweight {\nprivate:\n char symbol;\n string fontFamily;\n int fontSize;\n string color;\n\npublic:\n CharacterGlyph(char symbol, const string& fontFamily, int fontSize, const string& color)\n : symbol(symbol), fontFamily(fontFamily), fontSize(fontSize), color(color) {}\n\n void draw(int x, int y) override {\n cout << \"Drawing '\" << symbol << \"' [Font: \" << fontFamily \n << \", Size: \" << fontSize << \", Color: \" << color \n << \"] at (\" << x << \",\" << y << \")\" << endl;\n }\n};\n```\n\n```go\ntype CharacterGlyph struct {\n\tsymbol rune\n\tfontFamily string\n\tfontSize int\n\tcolor string\n}\n\nfunc NewCharacterGlyph(symbol rune, fontFamily string, fontSize int, color string) *CharacterGlyph {\n\treturn &CharacterGlyph{\n\t\tsymbol: symbol,\n\t\tfontFamily: fontFamily,\n\t\tfontSize: fontSize,\n\t\tcolor: color,\n\t}\n}\n\nfunc (c *CharacterGlyph) Draw(x, y int) {\n\tfmt.Printf(\"Drawing '%c' [Font: %s, Size: %d, Color: %s] at (%d,%d)\\n\", c.symbol, c.fontFamily, c.fontSize, c.color, x, y)\n}\n```\n\n```csharp\nclass CharacterGlyph : ICharacterFlyweight\n{\n private readonly char symbol;\n private readonly string fontFamily;\n private readonly int fontSize;\n private readonly string color;\n\n public CharacterGlyph(char symbol, string fontFamily, int fontSize, string color)\n {\n this.symbol = symbol;\n this.fontFamily = fontFamily;\n this.fontSize = fontSize;\n this.color = color;\n }\n\n public void Draw(int x, int y)\n {\n Console.WriteLine($\"Drawing '{symbol}' [Font: {fontFamily}, Size: {fontSize}, Color: {color}] at ({x},{y})\");\n }\n}\n```\n\n```typescript\nclass CharacterGlyph implements CharacterFlyweight {\n private readonly symbol: string;\n private readonly fontFamily: string;\n private readonly fontSize: number;\n private readonly color: string;\n\n constructor(symbol: string, fontFamily: string, fontSize: number, color: string) {\n this.symbol = symbol;\n this.fontFamily = fontFamily;\n this.fontSize = fontSize;\n this.color = color;\n }\n\n draw(x: number, y: number): void {\n console.log(\"Drawing '\" + this.symbol + \"' [Font: \" + this.fontFamily +\n \", Size: \" + this.fontSize + \", Color: \" + this.color + \"] at (\" + x + \",\" + y + \")\");\n }\n}\n```\n\n\nNotice that the constructor takes only four parameters, not six. Position is gone from the object's state entirely. The `final` (or `readonly`) modifiers reinforce that these fields are set once at creation and never change. \n\nThis immutability is what makes sharing safe: no matter how many clients reference the same flyweight, none of them can corrupt it.\n\n### Step 3: Create the Flyweight Factory\n\nThe factory is the heart of the pattern. It maintains a map of already-created flyweights, keyed by a string that concatenates all intrinsic fields. \n\nWhen a client requests a flyweight, the factory checks the map first. If a matching flyweight exists, it returns the cached instance. If not, it creates a new one, stores it, and returns it. This guarantees that identical combinations of intrinsic state are never duplicated.\n\n\n```java\nclass CharacterFlyweightFactory {\n private final Map flyweightMap = new HashMap<>();\n\n public CharacterFlyweight getFlyweight(char symbol, String fontFamily, int fontSize, String color) {\n String key = symbol + fontFamily + fontSize + color;\n flyweightMap.putIfAbsent(key, new CharacterGlyph(symbol, fontFamily, fontSize, color));\n return flyweightMap.get(key);\n }\n\n public int getFlyweightCount() {\n return flyweightMap.size();\n }\n}\n```\n\n```python\nclass CharacterFlyweightFactory:\n def __init__(self):\n self.flyweight_map = {}\n \n def get_flyweight(self, symbol, font_family, font_size, color):\n key = symbol + font_family + str(font_size) + color\n if key not in self.flyweight_map:\n self.flyweight_map[key] = CharacterGlyph(symbol, font_family, font_size, color)\n return self.flyweight_map[key]\n \n def get_flyweight_count(self):\n return len(self.flyweight_map)\n```\n\n```cpp\nclass CharacterFlyweightFactory {\nprivate:\n map flyweightMap;\n\npublic:\n CharacterFlyweight* getFlyweight(char symbol, const string& fontFamily, int fontSize, const string& color) {\n string key = string(1, symbol) + fontFamily + to_string(fontSize) + color;\n \n if (flyweightMap.find(key) == flyweightMap.end()) {\n flyweightMap[key] = new CharacterGlyph(symbol, fontFamily, fontSize, color);\n }\n \n return flyweightMap[key];\n }\n\n int getFlyweightCount() {\n return flyweightMap.size();\n }\n\n ~CharacterFlyweightFactory() {\n for (auto& pair : flyweightMap) {\n delete pair.second;\n }\n }\n};\n```\n\n```go\ntype CharacterFlyweightFactory struct {\n\tflyweightMap map[string]CharacterFlyweight\n}\n\nfunc (f *CharacterFlyweightFactory) GetFlyweight(symbol rune, fontFamily string, fontSize int, color string) CharacterFlyweight {\n\tkey := string(symbol) + fontFamily + strconv.Itoa(fontSize) + color\n\tif f.flyweightMap == nil {\n\t\tf.flyweightMap = make(map[string]CharacterFlyweight)\n\t}\n\tif _, ok := f.flyweightMap[key]; !ok {\n\t\tf.flyweightMap[key] = NewCharacterGlyph(symbol, fontFamily, fontSize, color)\n\t}\n\treturn f.flyweightMap[key]\n}\n\nfunc (f *CharacterFlyweightFactory) GetFlyweightCount() int {\n\treturn len(f.flyweightMap)\n}\n```\n\n```csharp\nclass CharacterFlyweightFactory\n{\n private readonly Dictionary flyweightMap = new Dictionary();\n\n public ICharacterFlyweight GetFlyweight(char symbol, string fontFamily, int fontSize, string color)\n {\n string key = symbol + fontFamily + fontSize + color;\n \n if (!flyweightMap.ContainsKey(key))\n {\n flyweightMap[key] = new CharacterGlyphFlyweight(symbol, fontFamily, fontSize, color);\n }\n \n return flyweightMap[key];\n }\n\n public int GetFlyweightCount()\n {\n return flyweightMap.Count;\n }\n}\n```\n\n```typescript\nclass CharacterFlyweightFactory {\n private readonly flyweightMap: Map = new Map();\n\n getFlyweight(symbol: string, fontFamily: string, fontSize: number, color: string): CharacterFlyweight {\n const key = symbol + fontFamily + fontSize + color;\n if (!this.flyweightMap.has(key)) {\n this.flyweightMap.set(key, new CharacterGlyph(symbol, fontFamily, fontSize, color));\n }\n return this.flyweightMap.get(key)!;\n }\n\n getFlyweightCount(): number {\n return this.flyweightMap.size;\n }\n}\n```\n\n\nThe factory guarantees that if two characters share the same symbol, font, size, and color, they will point to the exact same object in memory. The `getFlyweightCount` method is useful for verifying how much sharing actually occurred, which is especially helpful during testing and debugging.\n\n### Step 4: Create the Client\n\nThe client side consists of two parts. `RenderedCharacter` is a lightweight wrapper that pairs a shared flyweight with a specific position. `TextEditorClient` is the main orchestrator: it uses the factory to obtain flyweights, wraps them with position data, and renders the entire document.\n\n\n```java\nclass TextEditorClient {\n private final CharacterFlyweightFactory factory = new CharacterFlyweightFactory();\n private final List document = new ArrayList<>();\n\n public void addCharacter(char c, int x, int y, String font, int size, String color) {\n CharacterFlyweight glyph = factory.getFlyweight(c, font, size, color);\n document.add(new RenderedCharacter(glyph, x, y));\n }\n\n public void renderDocument() {\n for (RenderedCharacter rc : document) {\n rc.render();\n }\n System.out.println(\"Total flyweight objects used: \" + factory.getFlyweightCount());\n }\n\n private static class RenderedCharacter {\n private final CharacterFlyweight glyph;\n private final int x, y;\n\n public RenderedCharacter(CharacterFlyweight glyph, int x, int y) {\n this.glyph = glyph;\n this.x = x;\n this.y = y;\n }\n\n public void render() {\n glyph.draw(x, y);\n }\n }\n}\n```\n\n```python\nclass TextEditorClient:\n def __init__(self):\n self.factory = CharacterFlyweightFactory()\n self.document = []\n \n def add_character(self, c, x, y, font, size, color):\n glyph = self.factory.get_flyweight(c, font, size, color)\n self.document.append(RenderedCharacter(glyph, x, y))\n \n def render_document(self):\n for rc in self.document:\n rc.render()\n print(f\"Total flyweight objects used: {self.factory.get_flyweight_count()}\")\n\nclass RenderedCharacter:\n def __init__(self, glyph, x, y):\n self.glyph = glyph\n self.x = x\n self.y = y\n \n def render(self):\n self.glyph.draw(self.x, self.y)\n```\n\n```cpp\nclass RenderedCharacter {\nprivate:\n CharacterFlyweight* glyph;\n int x, y;\n\npublic:\n RenderedCharacter(CharacterFlyweight* glyph, int x, int y) : glyph(glyph), x(x), y(y) {}\n\n void render() {\n glyph->draw(x, y);\n }\n};\n\nclass TextEditorClient {\nprivate:\n CharacterFlyweightFactory factory;\n vector document;\n\npublic:\n void addCharacter(char c, int x, int y, const string& font, int size, const string& color) {\n CharacterFlyweight* glyph = factory.getFlyweight(c, font, size, color);\n document.push_back(RenderedCharacter(glyph, x, y));\n }\n\n void renderDocument() {\n for (RenderedCharacter& rc : document) {\n rc.render();\n }\n cout << \"Total flyweight objects used: \" << factory.getFlyweightCount() << endl;\n }\n};\n```\n\n```go\ntype RenderedCharacter struct {\n\tglyph CharacterFlyweight\n\tx, y int\n}\n\nfunc (rc RenderedCharacter) render() {\n\trc.glyph.draw(rc.x, rc.y)\n}\n\ntype TextEditorClient struct {\n\tfactory CharacterFlyweightFactory\n\tdocument []RenderedCharacter\n}\n\nfunc (t *TextEditorClient) addCharacter(c byte, x, y int, font string, size int, color string) {\n\tglyph := t.factory.getFlyweight(c, font, size, color)\n\tt.document = append(t.document, RenderedCharacter{glyph: glyph, x: x, y: y})\n}\n\nfunc (t *TextEditorClient) renderDocument() {\n\tfor _, rc := range t.document {\n\t\trc.render()\n\t}\n\tfmt.Println(\"Total flyweight objects used: \", t.factory.getFlyweightCount())\n}\n```\n\n```csharp\nclass RenderedCharacter\n{\n private readonly ICharacterFlyweight glyph;\n private readonly int x, y;\n\n public RenderedCharacter(ICharacterFlyweight glyph, int x, int y)\n {\n this.glyph = glyph;\n this.x = x;\n this.y = y;\n }\n\n public void Render()\n {\n glyph.Draw(x, y);\n }\n}\n\nclass TextEditorClient\n{\n private readonly CharacterFlyweightFactory factory = new CharacterFlyweightFactory();\n private readonly List document = new List();\n\n public void AddCharacter(char c, int x, int y, string font, int size, string color)\n {\n ICharacterFlyweight glyph = factory.GetFlyweight(c, font, size, color);\n document.Add(new RenderedCharacter(glyph, x, y));\n }\n\n public void RenderDocument()\n {\n foreach (RenderedCharacter rc in document)\n {\n rc.Render();\n }\n Console.WriteLine($\"Total flyweight objects used: {factory.GetFlyweightCount()}\");\n }\n}\n```\n\n```typescript\nclass TextEditorClient {\n private readonly factory = new CharacterFlyweightFactory();\n private readonly document: RenderedCharacter[] = [];\n\n addCharacter(c: string, x: number, y: number, font: string, size: number, color: string): void {\n const glyph = this.factory.getFlyweight(c, font, size, color);\n this.document.push(new RenderedCharacter(glyph, x, y));\n }\n\n renderDocument(): void {\n for (const rc of this.document) {\n rc.render();\n }\n console.log(\"Total flyweight objects used: \" + this.factory.getFlyweightCount());\n }\n\n private static class RenderedCharacter {\n private readonly glyph: CharacterFlyweight;\n private readonly x: number;\n private readonly y: number;\n\n constructor(glyph: CharacterFlyweight, x: number, y: number) {\n this.glyph = glyph;\n this.x = x;\n this.y = y;\n }\n\n render(): void {\n this.glyph.draw(this.x, this.y);\n }\n }\n}\n```\n\n\nEach `RenderedCharacter` is extremely lightweight. It holds just a reference to a shared flyweight and two integers for position. The heavy formatting data lives in the flyweight, and many `RenderedCharacter` instances can point to the same one. This is where the memory savings come from.\n\n### Using the Flyweight from the Client\n\nLet's put everything together. The demo renders two words with different formatting and shows how many flyweight objects were actually created versus how many characters were rendered.\n\n\n```java\npublic class FlyweightDemo {\n public static void main(String[] args) {\n TextEditorClient editor = new TextEditorClient();\n\n // Render \"Hello\" with same style\n String word = \"Hello\";\n for (int i = 0; i < word.length(); i++) {\n editor.addCharacter(word.charAt(i), 10 + i * 15, 50, \"Arial\", 14, \"#000000\");\n }\n\n // Render \"World\" with different font and color\n String word2 = \"World\";\n for (int i = 0; i < word2.length(); i++) {\n editor.addCharacter(word2.charAt(i), 10 + i * 15, 100, \"Times New Roman\", 14, \"#3333FF\");\n }\n\n editor.renderDocument();\n }\n}\n```\n\n```python\ndef flyweight_demo():\n editor = TextEditorClient()\n \n # Render \"Hello\" with same style\n word = \"Hello\"\n for i in range(len(word)):\n editor.add_character(word[i], 10 + i * 15, 50, \"Arial\", 14, \"#000000\")\n \n # Render \"World\" with different font and color\n word2 = \"World\"\n for i in range(len(word2)):\n editor.add_character(word2[i], 10 + i * 15, 100, \"Times New Roman\", 14, \"#3333FF\")\n \n editor.render_document()\n\n# Example usage\nif __name__ == \"__main__\":\n\n flyweight_demo()\n```\n\n```cpp\nvoid flyweightDemo() {\n TextEditorClient editor;\n\n // Render \"Hello\" with same style\n string word = \"Hello\";\n for (int i = 0; i < word.length(); i++) {\n editor.addCharacter(word[i], 10 + i * 15, 50, \"Arial\", 14, \"#000000\");\n }\n\n // Render \"World\" with different font and color\n string word2 = \"World\";\n for (int i = 0; i < word2.length(); i++) {\n editor.addCharacter(word2[i], 10 + i * 15, 100, \"Times New Roman\", 14, \"#3333FF\");\n }\n\n editor.renderDocument();\n}\n\nint main() {\n flyweightDemo();\n return 0;\n}\n```\n\n```go\nfunc flyweightDemo() {\n\teditor := TextEditorClient{}\n\n\t// Render \"Hello\" with same style\n\tword := \"Hello\"\n\tfor i := 0; i < len(word); i++ {\n\t\teditor.addCharacter(rune(word[i]), 10+i*15, 50, \"Arial\", 14, \"#000000\")\n\t}\n\n\t// Render \"World\" with different font and color\n\tword2 := \"World\"\n\tfor i := 0; i < len(word2); i++ {\n\t\teditor.addCharacter(rune(word2[i]), 10+i*15, 100, \"Times New Roman\", 14, \"#3333FF\")\n\t}\n\n\teditor.renderDocument()\n}\n```\n\n```csharp\npublic class Program\n{\n public static void Main(string[] args)\n {\n TextEditorClient editor = new TextEditorClient();\n\n // Render \"Hello\" with same style\n string word = \"Hello\";\n for (int i = 0; i < word.Length; i++)\n {\n editor.AddCharacter(word[i], 10 + i * 15, 50, \"Arial\", 14, \"#000000\");\n }\n\n // Render \"World\" with different font and color\n string word2 = \"World\";\n for (int i = 0; i < word2.Length; i++)\n {\n editor.AddCharacter(word2[i], 10 + i * 15, 100, \"Times New Roman\", 14, \"#3333FF\");\n }\n\n editor.RenderDocument();\n }\n}\n```\n\n```typescript\nclass FlyweightDemo {\n static main(): void {\n const editor = new TextEditorClient();\n\n // Render \"Hello\" with same style\n const word = \"Hello\";\n for (let i = 0; i < word.length; i++) {\n editor.addCharacter(word.charAt(i), 10 + i * 15, 50, \"Arial\", 14, \"#000000\");\n }\n\n // Render \"World\" with different font and color\n const word2 = \"World\";\n for (let i = 0; i < word2.length; i++) {\n editor.addCharacter(word2.charAt(i), 10 + i * 15, 100, \"Times New Roman\", 14, \"#3333FF\");\n }\n\n editor.renderDocument();\n }\n}\n```\n\n\n#### Sample Output:\n\n\n```plaintext\nDrawing 'H' [Font: Arial, Size: 14, Color: #000000] at (10,50)\nDrawing 'e' [Font: Arial, Size: 14, Color: #000000] at (25,50)\nDrawing 'l' [Font: Arial, Size: 14, Color: #000000] at (40,50)\nDrawing 'l' [Font: Arial, Size: 14, Color: #000000] at (55,50)\nDrawing 'o' [Font: Arial, Size: 14, Color: #000000] at (70,50)\nDrawing 'W' [Font: Times New Roman, Size: 14, Color: #3333FF] at (10,100)\nDrawing 'o' [Font: Times New Roman, Size: 14, Color: #3333FF] at (25,100)\nDrawing 'r' [Font: Times New Roman, Size: 14, Color: #3333FF] at (40,100)\nDrawing 'l' [Font: Times New Roman, Size: 14, Color: #3333FF] at (55,100)\nDrawing 'd' [Font: Times New Roman, Size: 14, Color: #3333FF] at (70,100)\nTotal flyweight objects used: 9\n```\n\n\nWe rendered 10 characters, but only 9 flyweight objects were created. Why 9 and not 10? Look at the word \"Hello\": the letter `l` appears twice at positions (40,50) and (55,50), but both occurrences use the same font, size, and color. The factory returns the same flyweight instance for both. That is one flyweight serving two rendered characters.\n\nYou might wonder why `o` in \"Hello\" and `o` in \"World\" did not share a flyweight. The reason is that they use different formatting: \"Hello\" is rendered in Arial with color `#000000`, while \"World\" uses Times New Roman with color `#3333FF`. The intrinsic state is different, so the factory correctly creates separate flyweight instances for each.\n\n### What We Achieved\n\n- **Memory efficiency:** Shared formatting eliminates duplication. Instead of storing font, size, and color in every character object, that data lives in a handful of flyweights.\n- **Improved performance:** Fewer objects means lower GC pressure and better cache utilization. The runtime spends less time allocating and collecting objects.\n- **Separation of concerns:** Formatting (intrinsic) and position (extrinsic) are cleanly separated. Changes to how position works do not affect the flyweight objects at all.\n- **Reusability:** Glyphs for common characters are reused across the entire document. The letter `e` in Arial 14 black is the same flyweight whether it appears on page 1 or page 50.\n- **Scalability:** A document with 500,000 characters might only need a few hundred flyweight objects (one per unique combination of character and formatting). Memory usage stays flat as document size grows.\n\n---\n\n# 4. Practical Example: Game Forest Rendering\n\nLet's apply the Flyweight pattern to a completely different domain. Imagine you are building a 2D game that renders a forest scene. The forest contains thousands of trees, but there are only a handful of distinct species. Each species has its own name, color, and texture, but every tree also has a unique position on the map.\n\nThis gives us a clean separation between the two types of state:\n\n- **Intrinsic state (shared):** species name, color, and texture. These properties are identical for every tree of the same species, so we can share them across all instances.\n- **Extrinsic state (unique):** the x and y coordinates on the map. Every tree placement has its own position, so this data stays outside the flyweight.\n\n### Class Diagram\n\n\n```mermaid\nclassDiagram\n class TreeType {\n <>\n +render(x, y)\n }\n\n class ConcreteTreeType {\n -name\n -color\n -texture\n +render(x, y)\n }\n\n class TreeTypeFactory {\n -treeTypes Map\n +getTreeType(name, color, texture)\n +getTypeCount()\n }\n\n class Tree {\n -type\n -x\n -y\n +draw()\n }\n\n class Forest {\n -factory\n -trees\n +plantTree(x, y, name, color, texture)\n +render()\n }\n\n TreeType <|.. ConcreteTreeType\n TreeTypeFactory --> TreeType : creates/caches\n Forest --> TreeTypeFactory : uses\n Forest --> Tree : manages\n Tree --> TreeType : references\n\n style TreeType fill:#69db7c,stroke:#000,color:#000\n style ConcreteTreeType fill:#00ceff,stroke:#000,color:#000\n style TreeTypeFactory fill:#38d9a9,stroke:#000,color:#000\n style Tree fill:#ffa94d,stroke:#000,color:#000\n style Forest fill:#ffa94d,stroke:#000,color:#000\n```\n\n\nThe `TreeType` interface defines the flyweight contract with a single `render` method that accepts extrinsic coordinates. `ConcreteTreeType` stores the heavy intrinsic data (name, color, texture) and implements rendering. The `TreeTypeFactory` maintains a cache of flyweights, creating new ones only when a species combination has not been seen before.\n\nEach `Tree` object is lightweight, holding just a reference to its shared `TreeType` plus its own x and y position. Finally, the `Forest` class ties everything together, using the factory to plant trees and delegating rendering to each tree.\n\n### Implementation\n\n\n```java\nimport java.util.ArrayList;\nimport java.util.HashMap;\nimport java.util.List;\nimport java.util.Map;\n\n// Flyweight interface\ninterface TreeType {\n void render(int x, int y);\n}\n\n// Concrete flyweight\nclass ConcreteTreeType implements TreeType {\n private final String name;\n private final String color;\n private final String texture;\n\n public ConcreteTreeType(String name, String color, String texture) {\n this.name = name;\n this.color = color;\n this.texture = texture;\n }\n\n @Override\n public void render(int x, int y) {\n System.out.println(\"Rendering \" + name + \" tree [color=\" + color +\n \", texture=\" + texture + \"] at (\" + x + \",\" + y + \")\");\n }\n}\n\n// Flyweight factory\nclass TreeTypeFactory {\n private final Map treeTypes = new HashMap<>();\n\n public TreeType getTreeType(String name, String color, String texture) {\n String key = name + \"_\" + color + \"_\" + texture;\n treeTypes.putIfAbsent(key, new ConcreteTreeType(name, color, texture));\n return treeTypes.get(key);\n }\n\n public int getTypeCount() {\n return treeTypes.size();\n }\n}\n\n// Extrinsic state holder\nclass Tree {\n private final TreeType type;\n private final int x;\n private final int y;\n\n public Tree(TreeType type, int x, int y) {\n this.type = type;\n this.x = x;\n this.y = y;\n }\n\n public void draw() {\n type.render(x, y);\n }\n}\n\n// Client\nclass Forest {\n private final TreeTypeFactory factory = new TreeTypeFactory();\n private final List trees = new ArrayList<>();\n\n public void plantTree(int x, int y, String name, String color, String texture) {\n TreeType type = factory.getTreeType(name, color, texture);\n trees.add(new Tree(type, x, y));\n }\n\n public void render() {\n for (Tree tree : trees) {\n tree.draw();\n }\n System.out.println(\"\\nTotal trees planted: \" + trees.size());\n System.out.println(\"Unique tree types created: \" + factory.getTypeCount());\n }\n}\n\npublic class ForestDemo {\n public static void main(String[] args) {\n Forest forest = new Forest();\n\n forest.plantTree(10, 20, \"Oak\", \"dark green\", \"rough bark\");\n forest.plantTree(50, 80, \"Pine\", \"green\", \"needle texture\");\n forest.plantTree(30, 60, \"Oak\", \"dark green\", \"rough bark\");\n forest.plantTree(70, 40, \"Birch\", \"light green\", \"white bark\");\n forest.plantTree(90, 10, \"Pine\", \"green\", \"needle texture\");\n\n forest.render();\n }\n}\n```\n\n```python\nfrom abc import ABC, abstractmethod\n\nclass TreeType(ABC):\n @abstractmethod\n def render(self, x: int, y: int):\n pass\n\nclass ConcreteTreeType(TreeType):\n def __init__(self, name: str, color: str, texture: str):\n self.name = name\n self.color = color\n self.texture = texture\n\n def render(self, x: int, y: int):\n print(f\"Rendering {self.name} tree [color={self.color}, \"\n f\"texture={self.texture}] at ({x},{y})\")\n\nclass TreeTypeFactory:\n def __init__(self):\n self._tree_types: dict[str, TreeType] = {}\n\n def get_tree_type(self, name: str, color: str, texture: str) -> TreeType:\n key = f\"{name}_{color}_{texture}\"\n if key not in self._tree_types:\n self._tree_types[key] = ConcreteTreeType(name, color, texture)\n return self._tree_types[key]\n\n def get_type_count(self) -> int:\n return len(self._tree_types)\n\nclass Tree:\n def __init__(self, tree_type: TreeType, x: int, y: int):\n self.tree_type = tree_type\n self.x = x\n self.y = y\n\n def draw(self):\n self.tree_type.render(self.x, self.y)\n\nclass Forest:\n def __init__(self):\n self._factory = TreeTypeFactory()\n self._trees: list[Tree] = []\n\n def plant_tree(self, x: int, y: int, name: str, color: str, texture: str):\n tree_type = self._factory.get_tree_type(name, color, texture)\n self._trees.append(Tree(tree_type, x, y))\n\n def render(self):\n for tree in self._trees:\n tree.draw()\n print(f\"\\nTotal trees planted: {len(self._trees)}\")\n print(f\"Unique tree types created: {self._factory.get_type_count()}\")\n\nif __name__ == \"__main__\":\n forest = Forest()\n\n forest.plant_tree(10, 20, \"Oak\", \"dark green\", \"rough bark\")\n forest.plant_tree(50, 80, \"Pine\", \"green\", \"needle texture\")\n forest.plant_tree(30, 60, \"Oak\", \"dark green\", \"rough bark\")\n forest.plant_tree(70, 40, \"Birch\", \"light green\", \"white bark\")\n forest.plant_tree(90, 10, \"Pine\", \"green\", \"needle texture\")\n\n forest.render()\n```\n\n```cpp\n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nclass TreeType {\npublic:\n virtual ~TreeType() {}\n virtual void render(int x, int y) = 0;\n};\n\nclass ConcreteTreeType : public TreeType {\nprivate:\n string name;\n string color;\n string texture;\n\npublic:\n ConcreteTreeType(string name, string color, string texture)\n : name(move(name)), color(move(color)), texture(move(texture)) {}\n\n void render(int x, int y) override {\n cout << \"Rendering \" << name << \" tree [color=\" << color\n << \", texture=\" << texture << \"] at (\" << x << \",\" << y << \")\" << endl;\n }\n};\n\nclass TreeTypeFactory {\nprivate:\n map treeTypes;\n\npublic:\n TreeType* getTreeType(const string& name, const string& color, const string& texture) {\n string key = name + \"_\" + color + \"_\" + texture;\n if (treeTypes.find(key) == treeTypes.end()) {\n treeTypes[key] = new ConcreteTreeType(name, color, texture);\n }\n return treeTypes[key];\n }\n\n int getTypeCount() {\n return treeTypes.size();\n }\n\n ~TreeTypeFactory() {\n for (auto& pair : treeTypes) {\n delete pair.second;\n }\n }\n};\n\nclass Tree {\nprivate:\n TreeType* type;\n int x, y;\n\npublic:\n Tree(TreeType* type, int x, int y) : type(type), x(x), y(y) {}\n\n void draw() {\n type->render(x, y);\n }\n};\n\nclass Forest {\nprivate:\n TreeTypeFactory factory;\n vector trees;\n\npublic:\n void plantTree(int x, int y, const string& name, const string& color, const string& texture) {\n TreeType* type = factory.getTreeType(name, color, texture);\n trees.emplace_back(type, x, y);\n }\n\n void render() {\n for (Tree& tree : trees) {\n tree.draw();\n }\n cout << \"\\nTotal trees planted: \" << trees.size() << endl;\n cout << \"Unique tree types created: \" << factory.getTypeCount() << endl;\n }\n};\n\nint main() {\n Forest forest;\n\n forest.plantTree(10, 20, \"Oak\", \"dark green\", \"rough bark\");\n forest.plantTree(50, 80, \"Pine\", \"green\", \"needle texture\");\n forest.plantTree(30, 60, \"Oak\", \"dark green\", \"rough bark\");\n forest.plantTree(70, 40, \"Birch\", \"light green\", \"white bark\");\n forest.plantTree(90, 10, \"Pine\", \"green\", \"needle texture\");\n\n forest.render();\n return 0;\n}\n```\n\n```go\npackage main\n\nimport \"fmt\"\n\n// Flyweight interface\ntype TreeType interface {\n\trender(x, y int)\n}\n\n// Concrete flyweight\ntype ConcreteTreeType struct {\n\tname string\n\tcolor string\n\ttexture string\n}\n\nfunc NewConcreteTreeType(name, color, texture string) *ConcreteTreeType {\n\treturn &ConcreteTreeType{name: name, color: color, texture: texture}\n}\n\nfunc (t *ConcreteTreeType) render(x, y int) {\n\tfmt.Printf(\"Rendering %s tree [color=%s, texture=%s] at (%d,%d)\\n\", t.name, t.color, t.texture, x, y)\n}\n\n// Flyweight factory\ntype TreeTypeFactory struct {\n\ttreeTypes map[string]TreeType\n}\n\nfunc NewTreeTypeFactory() *TreeTypeFactory {\n\treturn &TreeTypeFactory{treeTypes: make(map[string]TreeType)}\n}\n\nfunc (f *TreeTypeFactory) getTreeType(name, color, texture string) TreeType {\n\tkey := name + \"_\" + color + \"_\" + texture\n\tif _, ok := f.treeTypes[key]; !ok {\n\t\tf.treeTypes[key] = NewConcreteTreeType(name, color, texture)\n\t}\n\treturn f.treeTypes[key]\n}\n\nfunc (f *TreeTypeFactory) getTypeCount() int {\n\treturn len(f.treeTypes)\n}\n\n// Extrinsic state holder\ntype Tree struct {\n\ttype_ TreeType\n\tx int\n\ty int\n}\n\nfunc NewTree(type_ TreeType, x, y int) *Tree {\n\treturn &Tree{type_: type_, x: x, y: y}\n}\n\nfunc (t *Tree) draw() {\n\tt.type_.render(t.x, t.y)\n}\n\n// Client\ntype Forest struct {\n\tfactory *TreeTypeFactory\n\ttrees []*Tree\n}\n\nfunc NewForest() *Forest {\n\treturn &Forest{factory: NewTreeTypeFactory(), trees: make([]*Tree, 0)}\n}\n\nfunc (f *Forest) plantTree(x, y int, name, color, texture string) {\n\ttype_ := f.factory.getTreeType(name, color, texture)\n\tf.trees = append(f.trees, NewTree(type_, x, y))\n}\n\nfunc (f *Forest) render() {\n\tfor _, tree := range f.trees {\n\t\ttree.draw()\n\t}\n\tfmt.Printf(\"\\nTotal trees planted: %d\\n\", len(f.trees))\n\tfmt.Printf(\"Unique tree types created: %d\\n\", f.factory.getTypeCount())\n}\n\nfunc main() {\n\tforest := NewForest()\n\n\tforest.plantTree(10, 20, \"Oak\", \"dark green\", \"rough bark\")\n\tforest.plantTree(50, 80, \"Pine\", \"green\", \"needle texture\")\n\tforest.plantTree(30, 60, \"Oak\", \"dark green\", \"rough bark\")\n\tforest.plantTree(70, 40, \"Birch\", \"light green\", \"white bark\")\n\tforest.plantTree(90, 10, \"Pine\", \"green\", \"needle texture\")\n\n\tforest.render()\n}\n```\n\n```csharp\nusing System;\nusing System.Collections.Generic;\n\ninterface ITreeType\n{\n void Render(int x, int y);\n}\n\nclass ConcreteTreeType : ITreeType\n{\n private readonly string name;\n private readonly string color;\n private readonly string texture;\n\n public ConcreteTreeType(string name, string color, string texture)\n {\n this.name = name;\n this.color = color;\n this.texture = texture;\n }\n\n public void Render(int x, int y)\n {\n Console.WriteLine($\"Rendering {name} tree [color={color}, texture={texture}] at ({x},{y})\");\n }\n}\n\nclass TreeTypeFactory\n{\n private readonly Dictionary treeTypes = new Dictionary();\n\n public ITreeType GetTreeType(string name, string color, string texture)\n {\n string key = name + \"_\" + color + \"_\" + texture;\n if (!treeTypes.ContainsKey(key))\n {\n treeTypes[key] = new ConcreteTreeType(name, color, texture);\n }\n return treeTypes[key];\n }\n\n public int GetTypeCount()\n {\n return treeTypes.Count;\n }\n}\n\nclass Tree\n{\n private readonly ITreeType type;\n private readonly int x;\n private readonly int y;\n\n public Tree(ITreeType type, int x, int y)\n {\n this.type = type;\n this.x = x;\n this.y = y;\n }\n\n public void Draw()\n {\n type.Render(x, y);\n }\n}\n\nclass Forest\n{\n private readonly TreeTypeFactory factory = new TreeTypeFactory();\n private readonly List trees = new List();\n\n public void PlantTree(int x, int y, string name, string color, string texture)\n {\n ITreeType type = factory.GetTreeType(name, color, texture);\n trees.Add(new Tree(type, x, y));\n }\n\n public void Render()\n {\n foreach (Tree tree in trees)\n {\n tree.Draw();\n }\n Console.WriteLine($\"\\nTotal trees planted: {trees.Count}\");\n Console.WriteLine($\"Unique tree types created: {factory.GetTypeCount()}\");\n }\n}\n\npublic class ForestDemo\n{\n public static void Main()\n {\n Forest forest = new Forest();\n\n forest.PlantTree(10, 20, \"Oak\", \"dark green\", \"rough bark\");\n forest.PlantTree(50, 80, \"Pine\", \"green\", \"needle texture\");\n forest.PlantTree(30, 60, \"Oak\", \"dark green\", \"rough bark\");\n forest.PlantTree(70, 40, \"Birch\", \"light green\", \"white bark\");\n forest.PlantTree(90, 10, \"Pine\", \"green\", \"needle texture\");\n\n forest.Render();\n }\n}\n```\n\n```typescript\n// Flyweight interface\ninterface TreeType {\n render(x: number, y: number): void;\n}\n\n// Concrete flyweight\nclass ConcreteTreeType implements TreeType {\n private readonly name: string;\n private readonly color: string;\n private readonly texture: string;\n\n constructor(name: string, color: string, texture: string) {\n this.name = name;\n this.color = color;\n this.texture = texture;\n }\n\n render(x: number, y: number): void {\n console.log(\n `Rendering ${this.name} tree [color=${this.color}, texture=${this.texture}] at (${x},${y})`\n );\n }\n}\n\n// Flyweight factory\nclass TreeTypeFactory {\n private readonly treeTypes: Map = new Map();\n\n getTreeType(name: string, color: string, texture: string): TreeType {\n const key = `${name}_${color}_${texture}`;\n if (!this.treeTypes.has(key)) {\n this.treeTypes.set(key, new ConcreteTreeType(name, color, texture));\n }\n // Non-null because we ensure set() above\n return this.treeTypes.get(key) as TreeType;\n }\n\n getTypeCount(): number {\n return this.treeTypes.size;\n }\n}\n\n// Extrinsic state holder\nclass Tree {\n private readonly type: TreeType;\n private readonly x: number;\n private readonly y: number;\n\n constructor(type: TreeType, x: number, y: number) {\n this.type = type;\n this.x = x;\n this.y = y;\n }\n\n draw(): void {\n this.type.render(this.x, this.y);\n }\n}\n\n// Client\nclass Forest {\n private readonly factory = new TreeTypeFactory();\n private readonly trees: Tree[] = [];\n\n plantTree(x: number, y: number, name: string, color: string, texture: string): void {\n const type = this.factory.getTreeType(name, color, texture);\n this.trees.push(new Tree(type, x, y));\n }\n\n render(): void {\n for (const tree of this.trees) {\n tree.draw();\n }\n console.log(`\\nTotal trees planted: ${this.trees.length}`);\n console.log(`Unique tree types created: ${this.factory.getTypeCount()}`);\n }\n}\n\nconst forest = new Forest();\n\nforest.plantTree(10, 20, \"Oak\", \"dark green\", \"rough bark\");\nforest.plantTree(50, 80, \"Pine\", \"green\", \"needle texture\");\nforest.plantTree(30, 60, \"Oak\", \"dark green\", \"rough bark\");\nforest.plantTree(70, 40, \"Birch\", \"light green\", \"white bark\");\nforest.plantTree(90, 10, \"Pine\", \"green\", \"needle texture\");\n\nforest.render();\n```\n\n\nFive trees in the forest, but only three TreeType flyweight objects in memory. The two Oak trees share one flyweight, and the two Pine trees share another. In a real game with 10,000 trees and 15 species, you would have 10,000 Tree objects (each holding just a reference and two coordinates) but only 15 ConcreteTreeType objects storing the heavy texture and color data.\n\nThat is the power of Flyweight in a domain where memory directly impacts frame rate.","pageType":"lld-interviews"}

Get Premium