Why structural patterns organize class relationships in LLD - Design It to Understand It

Design: Structural Patterns in Class Relationships

In scope: Understanding and explaining structural design patterns and their role in organizing class relationships. Out of scope: Detailed implementation of behavioral or creational patterns.

Functional Requirements

FR1: Explain how structural patterns help organize classes

FR2: Show how these patterns improve code reuse and flexibility

FR3: Demonstrate relationships like composition, inheritance, and delegation

FR4: Provide examples of common structural patterns

Non-Functional Requirements

NFR1: Focus on class-level organization, not object behavior

NFR2: Keep explanations simple and relatable

NFR3: Use clear examples to illustrate relationships

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

Key Components

Classes and interfaces

Composition and aggregation

Inheritance and delegation

Wrapper or adapter classes

Design Patterns

Adapter pattern

Decorator pattern

Facade pattern

Composite pattern

Proxy pattern

Reference Architecture

Facade

uses→Subsystem Classes

↓

Client

uses→Adapter

↓

Component

↓

Component

↓

Decorator

wraps→Component

↓

Proxy

controls access→RealSubject

Components

Facade

Class

Simplifies complex subsystem by providing a unified interface

Adapter

Class

Converts interface of one class to another expected by client

Composite

Class

Allows treating individual objects and compositions uniformly

Decorator

Class

Adds responsibilities to objects dynamically without changing their interface

Proxy

Class

Controls access to another object, adding a level of indirection

Request Flow

1. Client calls Facade to interact with complex subsystem without knowing details

2. Adapter receives client calls and translates them to Adaptee's interface

3. Composite manages a tree of Components, forwarding client calls to children or leaves

4. Decorator wraps a Component and adds extra behavior before or after forwarding calls

5. Proxy intercepts client requests and controls access to the RealSubject

Database Schema

Not applicable as this is a class relationship design topic focusing on code structure rather than data storage.

Scaling Discussion

Bottlenecks

Tight coupling between classes making changes risky

Complex dependencies causing maintenance difficulties

Rigid class hierarchies limiting reuse

Excessive subclassing leading to class explosion

Solutions

Use structural patterns to reduce coupling by introducing interfaces and wrappers

Apply composition over inheritance to increase flexibility

Use Decorator and Proxy to add behavior without modifying existing classes

Use Facade to hide complexity and reduce dependency exposure

Interview Tips

Time: Spend 10 minutes explaining the purpose of structural patterns, 15 minutes walking through examples of key patterns, and 10 minutes discussing benefits and trade-offs.

Structural patterns organize class relationships to improve code reuse and flexibility

They help manage dependencies and reduce tight coupling

Common patterns include Adapter, Decorator, Facade, Composite, and Proxy

Using these patterns leads to easier maintenance and scalability

Practice

1. What is the main purpose of structural design patterns in organizing class relationships?

easy

A. To simplify system design by organizing how classes relate

B. To improve the speed of the program execution

C. To handle user input and output operations

D. To store data persistently in databases

Solution

1. Step 1: Understand the role of structural patterns

   Structural patterns focus on how classes and objects are composed to form larger structures.

2. Step 2: Identify the main goal

   The main goal is to simplify the design by making relationships flexible and clear.

3. Final Answer:

   To simplify system design by organizing how classes relate -> Option A

4. Quick Check:

   Structural patterns simplify class relationships [OK]

Hint: Structural patterns simplify class connections [OK]

Common Mistakes:

• Confusing structural patterns with performance optimization
• Thinking structural patterns manage data storage
• Mixing structural patterns with user interface handling

2. Which of the following is a correct example of a structural pattern that organizes class relationships?

easy

A. Factory pattern

B. Singleton pattern

C. Adapter pattern

D. Observer pattern

Solution

1. Step 1: Recall common structural patterns

   Adapter, Decorator, and Composite are examples of structural patterns.

2. Step 2: Match options to pattern types

   Adapter is a structural pattern; Singleton is creational; Observer is behavioral; Factory is creational.

3. Final Answer:

   Adapter pattern -> Option C

4. Quick Check:

   Adapter = Structural pattern [OK]

Hint: Adapter is a classic structural pattern [OK]

Common Mistakes:

• Confusing creational patterns with structural ones
• Selecting Observer which is behavioral
• Choosing Factory which is creational

3. Given the following class structure using the Decorator pattern, what is the main benefit of this design?

class Coffee {
  cost() { return 5; }
}
class MilkDecorator {
  constructor(coffee) { this.coffee = coffee; }
  cost() { return this.coffee.cost() + 2; }
}

medium

A. It speeds up the cost calculation by caching results

B. It allows adding features dynamically without changing original classes

C. It restricts the coffee class from being extended

D. It stores coffee objects in a database

Solution

1. Step 1: Analyze the Decorator pattern usage

   The MilkDecorator wraps a Coffee object and adds extra cost dynamically.

2. Step 2: Understand the benefit

   This design allows adding new features (like milk) without modifying the original Coffee class.

3. Final Answer:

   It allows adding features dynamically without changing original classes -> Option B

4. Quick Check:

   Decorator adds features dynamically [OK]

Hint: Decorator adds features without changing original class [OK]

Common Mistakes:

• Thinking it caches results for speed
• Believing it restricts class extension
• Assuming it handles data storage

4. Identify the error in this Adapter pattern implementation:

class OldSystem {
  oldRequest() { return 'Old response'; }
}
class Adapter {
  constructor(oldSystem) { this.oldSystem = oldSystem; }
  request() { return this.oldSystem.request(); }
}

medium

A. Adapter should inherit from OldSystem

B. OldSystem class should not have any methods

C. Constructor is missing in OldSystem

D. Adapter calls a non-existent method 'request' instead of 'oldRequest'

Solution

1. Step 1: Check method calls in Adapter

   Adapter calls this.oldSystem.request(), but OldSystem has only oldRequest() method.

2. Step 2: Identify the mismatch

   The Adapter should call oldRequest() to adapt it to request().

3. Final Answer:

   Adapter calls a non-existent method 'request' instead of 'oldRequest' -> Option D

4. Quick Check:

   Method name mismatch in Adapter [OK]

Hint: Check method names carefully in Adapter calls [OK]

Common Mistakes:

• Assuming inheritance is required in Adapter
• Thinking OldSystem should be empty
• Ignoring method name differences

5. You need to design a system where multiple objects form a tree structure and clients treat individual objects and compositions uniformly. Which structural pattern best organizes this relationship?

hard

A. Composite pattern

B. Facade pattern

C. Proxy pattern

D. Bridge pattern

Solution

1. Step 1: Understand the problem requirements

   The system needs to treat individual objects and groups (tree structure) uniformly.

2. Step 2: Match with structural patterns

   The Composite pattern allows composing objects into tree structures and clients treat them the same.

3. Step 3: Eliminate other options

   Facade simplifies interfaces, Proxy controls access, Bridge separates abstraction from implementation; none fit the tree structure need.

4. Final Answer:

   Composite pattern -> Option A

5. Quick Check:

   Tree structure uniform treatment = Composite [OK]

Hint: Composite handles tree structures uniformly [OK]

Common Mistakes:

• Confusing Facade with Composite
• Choosing Proxy for access control only
• Mixing Bridge with structural composition