Open/Closed Principle in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding the Open/Closed Principle

Which statement best describes the Open/Closed Principle in software design?

A Software entities should be open for extension but closed for modification.

B Software entities should be open for modification but closed for extension.

C Software entities should always be rewritten when requirements change.

D Software entities should be neither open for extension nor modification.

💡 Hint

Think about how to add new features without changing existing code.

The Open/Closed Principle means you can add new behavior by extending code, not by changing existing code, which helps avoid bugs.

❓ Architecture

intermediate

Applying Open/Closed Principle in Module Design

You have a payment processing system that currently supports credit cards. You want to add support for new payment methods without changing existing payment code. Which design approach follows the Open/Closed Principle?

A Create a PaymentMethod interface and implement new classes for each payment type, then use polymorphism to process payments.

B Add new if-else conditions in the existing payment processing class for each new payment type.

C Rewrite the entire payment processing class every time a new payment method is added.

D Use global variables to switch payment methods dynamically.

💡 Hint

Think about how to add new payment types without changing existing code.

Using interfaces and polymorphism allows adding new payment types by creating new classes, keeping existing code unchanged.

❓ scaling

advanced

Scaling a Notification System with Open/Closed Principle

You have a notification system that sends alerts via email. You want to add SMS and push notifications without modifying existing email notification code. What is the best scalable design following the Open/Closed Principle?

A Use a single Notification class with many conditional statements for each notification type.

B Add SMS and push notification code directly inside the existing EmailNotification class.

C Duplicate the entire notification system code for each new notification type.

D Create a Notification interface and implement EmailNotification, SMSNotification, and PushNotification classes; use a factory to instantiate them.

💡 Hint

Consider how to add new notification types without changing existing classes.

Using an interface and separate classes for each notification type allows adding new types by extension, not modification, supporting scalability.

❓ tradeoff

advanced

Tradeoffs of Strictly Following Open/Closed Principle

What is a common tradeoff when strictly applying the Open/Closed Principle in system design?

A Reduced code reuse because everything is written from scratch.

B Increased number of classes and interfaces, which can make the system more complex to understand.

C Decreased flexibility since existing code must be modified frequently.

D Lower maintainability due to tightly coupled components.

💡 Hint

Think about how adding extensions affects code structure.

Following Open/Closed Principle often leads to more classes and interfaces, increasing complexity but improving extensibility and safety.

❓ component

expert

Identifying Violation of Open/Closed Principle in Component Design

Given a logging component that writes logs to a file, which change violates the Open/Closed Principle?

Options describe changes to add new logging outputs.

A Creating a new ConsoleLogger class implementing the Logger interface and using it alongside the file logger.

B Adding a new class that implements a Logger interface to support database logging without changing existing file logger code.

C Modifying the existing file logger class to add conditional code for console logging.

D Using a logging manager class that delegates logging to different logger implementations.

💡 Hint

Look for changes that modify existing code instead of extending it.

Modifying existing classes to add new behavior breaks the Open/Closed Principle; new functionality should be added by extension.