Facade pattern in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Purpose of the Facade Pattern

What is the main purpose of using the Facade pattern in system design?

A To replace all subsystem classes with a single class

B To enforce strict access control on all system components

C To provide a simplified interface to a complex subsystem

D To increase the number of classes for better modularity

💡 Hint

Think about how a facade helps users interact with complex systems.

The Facade pattern provides a simple interface to a complex set of classes or subsystems, making it easier for clients to use the system without dealing with its complexity.

❓ Architecture

intermediate

Identifying Facade Components

In a system using the Facade pattern, which component acts as the facade?

A A class that directly interacts with multiple subsystem classes and exposes a simple interface

B A low-level subsystem class that handles detailed operations

C A utility class that provides helper functions unrelated to subsystems

D A client class that uses the subsystem classes directly

💡 Hint

Consider which class hides complexity from the client.

The facade class wraps multiple subsystem classes and provides a simple interface for clients to interact with the system.

❓ scaling

advanced

Scaling a System with Facade Pattern

You have a large system with many subsystems. How does using the Facade pattern help when scaling the system?

A It forces clients to manage subsystem dependencies directly for better control

B It duplicates subsystem classes to handle more requests simultaneously

C It removes the need for subsystems, replacing them with a single facade class

D It reduces the number of client-subsystem interactions, making scaling easier by centralizing access

💡 Hint

Think about how centralizing access affects system complexity and scaling.

The facade centralizes subsystem access, reducing client complexity and making it easier to manage and scale the system.

❓ tradeoff

advanced

Tradeoffs of Using Facade Pattern

What is a potential tradeoff when using the Facade pattern in a complex system?

A It increases the number of classes, making the system harder to understand

B It can hide important subsystem features, limiting client flexibility

C It forces clients to interact with subsystems directly, increasing complexity

D It eliminates the need for subsystem classes, reducing modularity

💡 Hint

Consider what might be lost when simplifying interfaces.

While the facade simplifies usage, it may hide some subsystem features that clients might need, reducing flexibility.

❓ component

expert

Request Flow in Facade Pattern

Consider a facade class that coordinates three subsystems: A, B, and C. A client calls a facade method that internally calls methods in these subsystems. What is the correct sequence of calls if the facade first calls subsystem A, then B, then C?

A 1,2,3,4,5,6,7

B 1,3,5,2,4,6,7

C 7,1,2,3,4,5,6

D 2,1,4,3,6,5,7

💡 Hint

Think about the order of calls and completions in a synchronous flow.

The facade calls subsystem methods in order, waits for each to complete, then proceeds to the next, finally returning the result to the client.

Practice

1. What is the main purpose of the Facade pattern in system design?

easy

A. To make the system slower by adding extra layers

B. To increase the number of classes in a system

C. To provide a simple interface to a complex system

D. To replace all subsystem classes with one class

Solution

1. Step 1: Understand the Facade pattern role

   The Facade pattern is designed to simplify interactions by providing a single interface to a complex system.

2. Step 2: Compare options with the pattern's purpose

   To provide a simple interface to a complex system correctly states the purpose. Options A, B, and C describe incorrect or harmful effects.

3. Final Answer:

   To provide a simple interface to a complex system -> Option C

4. Quick Check:

   Facade pattern = Simple interface [OK]

Hint: Facade means simple front for complex system [OK]

Common Mistakes:

• Thinking Facade replaces all classes
• Believing Facade adds complexity
• Confusing Facade with Singleton pattern

2. Which of the following is the correct way to define a Facade class method in a typical object-oriented language?

easy

A. private void complexOperation() { subsystem1.action(); }

B. public int complexOperation() { subsystem1.action(); subsystem2.action(); return 0; }

C. void complexOperation() { return subsystem1.action(); }

D. public void complexOperation() { subsystem1.action(); subsystem2.action(); }

Solution

1. Step 1: Identify Facade method visibility and calls

   Facade methods are usually public to expose simplified operations and call multiple subsystems internally.

2. Step 2: Check each option's correctness

   public void complexOperation() { subsystem1.action(); subsystem2.action(); } is public and calls multiple subsystems, matching Facade pattern. private void complexOperation() { subsystem1.action(); } is private, so not accessible. void complexOperation() { return subsystem1.action(); } returns a value but calls only one subsystem. public int complexOperation() { subsystem1.action(); subsystem2.action(); return 0; } returns int unnecessarily.

3. Final Answer:

   public void complexOperation() { subsystem1.action(); subsystem2.action(); } -> Option D

4. Quick Check:

   Facade method = public + multiple calls [OK]

Hint: Facade methods are public and call multiple subsystems [OK]

Common Mistakes:

• Making Facade methods private
• Returning values unnecessarily
• Calling only one subsystem inside Facade

3. Given this Facade code snippet, what will be the output?

class SubsystemA {
  void operationA() { print('A'); }
}
class SubsystemB {
  void operationB() { print('B'); }
}
class Facade {
  SubsystemA a = SubsystemA();
  SubsystemB b = SubsystemB();
  void doWork() {
    a.operationA();
    b.operationB();
  }
}
void main() {
  Facade f = Facade();
  f.doWork();
}

medium

A. BA

B. AB

C. A B

D. No output

Solution

1. Step 1: Trace Facade's doWork method calls

   doWork calls operationA() then operationB(), which print 'A' and 'B' respectively.

2. Step 2: Determine output sequence

   Since operationA prints 'A' first, then operationB prints 'B', output is 'AB' without spaces.

3. Final Answer:

   AB -> Option B

4. Quick Check:

   Facade calls order = AB [OK]

Hint: Follow method calls in order to find output [OK]

Common Mistakes:

• Assuming output is 'BA' reversing calls
• Expecting spaces between prints
• Thinking no output due to missing return

4. Identify the error in this Facade implementation:

class Subsystem {
  void action() { print('Action'); }
}
class Facade {
  Subsystem subsystem;
  void doTask() {
    subsystem.action();
  }
}
void main() {
  Facade f = Facade();
  f.doTask();
}

medium

A. Subsystem object is not initialized before use

B. Facade class should not call subsystem methods

C. doTask method should return a value

D. Subsystem class should be abstract

Solution

1. Step 1: Check subsystem object usage in Facade

   The Facade has a subsystem field but never initializes it before calling action(), causing a null reference error.

2. Step 2: Validate other options

   Facade class should not call subsystem methods is wrong because Facade should call subsystem methods. doTask method should return a value is not required. Subsystem class should be abstract is unnecessary.

3. Final Answer:

   Subsystem object is not initialized before use -> Option A

4. Quick Check:

   Uninitialized object = runtime error [OK]

Hint: Always initialize objects before calling methods [OK]

Common Mistakes:

• Ignoring null object initialization
• Thinking Facade should not call subsystems
• Expecting return values unnecessarily

5. You are designing a home automation system with many devices: lights, thermostat, security cameras, and music system. How would applying the Facade pattern help in this scenario?

hard

A. Create a single HomeAutomationFacade class that provides simple methods like turnOnAll() and setTemperature() to control all devices

B. Replace all device classes with one large class containing all device logic

C. Make each device class inherit from a common Facade superclass

D. Use Facade pattern to split each device into smaller classes

Solution

1. Step 1: Understand Facade's role in simplifying complex systems

   Facade groups multiple subsystem calls into simple methods, hiding complexity from users.

2. Step 2: Apply this to home automation

   Create a single HomeAutomationFacade class that provides simple methods like turnOnAll() and setTemperature() to control all devices correctly describes creating a Facade class with simple methods controlling multiple devices. Options A, B, and D misunderstand Facade's purpose.

3. Final Answer:

   Create a single HomeAutomationFacade class that provides simple methods like turnOnAll() and setTemperature() to control all devices -> Option A

4. Quick Check:

   Facade = simple interface for complex devices [OK]

Hint: Facade groups complex calls into simple methods [OK]

Common Mistakes:

• Merging all logic into one big class
• Confusing Facade with inheritance
• Splitting devices further instead of simplifying