Interface Segregation Principle in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Interface Segregation Principle (ISP)

Which statement best describes the Interface Segregation Principle?

A Interfaces should be merged to reduce the number of classes in a system.

B All classes should implement a single large interface to ensure consistency.

C Interfaces should only be used for database access layers.

D Clients should not be forced to depend on interfaces they do not use.

💡 Hint

Think about how interfaces affect client dependencies and code flexibility.

The Interface Segregation Principle states that clients should not be forced to depend on interfaces they do not use. This promotes smaller, more specific interfaces rather than large, general ones.

❓ Architecture

intermediate

Applying ISP in a Payment System

You are designing a payment system with multiple payment methods: CreditCard, PayPal, and Bitcoin. Which design best follows the Interface Segregation Principle?

A Create a single interface IPayment with a generic pay() method that all payment classes implement.

B Do not use interfaces; implement payment methods directly in one class.

C Create separate interfaces for each payment method: ICreditCardPayment, IPayPalPayment, IBitcoinPayment. Each payment class implements only the relevant interface.

D Create one large interface IPayment with methods: payWithCreditCard(), payWithPayPal(), payWithBitcoin(). All payment classes implement all methods.

💡 Hint

Consider how to avoid forcing classes to implement methods they don't need.

ISP encourages creating smaller, specific interfaces so classes implement only what they need. Separate interfaces for each payment method avoid unnecessary dependencies.

❓ scaling

advanced

Scaling a Notification System with ISP

A notification system supports Email, SMS, and Push notifications. As the system grows, which approach best supports scalability and follows ISP?

A Use one interface INotification with methods sendEmail(), sendSMS(), sendPush(). All notification classes implement all methods.

B Create separate interfaces IEmailNotification, ISMSNotification, IPushNotification. Notification classes implement only the interfaces they support.

C Implement all notification methods in a single NotificationManager class without interfaces.

D Use a single interface with a send(type, message) method handling all notification types.

💡 Hint

Think about how adding new notification types affects existing classes.

Separate interfaces allow adding new notification types without changing existing classes, supporting scalability and adhering to ISP.

❓ tradeoff

advanced

Tradeoffs of Interface Segregation Principle

What is a common tradeoff when applying the Interface Segregation Principle in system design?

A It can increase the number of interfaces, making the system more complex to manage.

B It forces all clients to depend on a single large interface, reducing flexibility.

C It eliminates the need for interfaces, simplifying the codebase.

D It requires all classes to implement every method, increasing code duplication.

💡 Hint

Consider the balance between interface size and system complexity.

While ISP improves modularity, it can lead to many small interfaces, which may increase management overhead.

❓ component

expert

Identifying ISP Violation in Code Components

Given a system with a Printer interface having methods print(), scan(), fax(), and a class BasicPrinter implementing all methods but only supporting print(), what problem does this design illustrate?

A Violation of Interface Segregation Principle because BasicPrinter depends on methods it does not use.

B Correct use of ISP because all methods are in one interface.

C Violation of Single Responsibility Principle because BasicPrinter does too many things.

D No problem; this is standard interface design.

💡 Hint

Think about whether classes should implement methods they don't support.

BasicPrinter implementing unused methods violates ISP because it depends on methods it does not need, leading to unnecessary complexity.

Practice

1. What is the main idea behind the Interface Segregation Principle in system design?

easy

A. Interfaces should be as large as possible to cover all features.

B. All classes must implement every method of an interface.

C. Clients should only depend on methods they actually use.

D. Interfaces should be avoided to reduce complexity.

Solution

1. Step 1: Understand the principle's goal

   The Interface Segregation Principle aims to keep interfaces small and focused so clients are not forced to depend on unused methods.

2. Step 2: Match the correct description

   Clients should only depend on methods they actually use. correctly states that clients should only depend on methods they use, which aligns with the principle.

3. Final Answer:

   Clients should only depend on methods they actually use. -> Option C

4. Quick Check:

   Interface Segregation Principle = Clients depend only on used methods [OK]

Hint: Focus on clients using only needed methods [OK]

Common Mistakes:

• Thinking interfaces must be large and cover all features
• Believing all classes must implement every interface method
• Assuming interfaces should be avoided

2. Which of the following interface definitions follows the Interface Segregation Principle?

easy

A. interface Printer { void print(); void scan(); void fax(); }

B. interface Machine { void doEverything(); }

C. interface Device { void operate(); void print(); void scan(); void fax(); }

D. interface Printer { void print(); } interface Scanner { void scan(); }

Solution

1. Step 1: Analyze interface sizes

   interface Printer { void print(); } interface Scanner { void scan(); } splits responsibilities into separate interfaces for printing and scanning, keeping them focused and small.

2. Step 2: Compare with other options

   Options A, B, and C combine multiple unrelated methods into one interface, violating the principle.

3. Final Answer:

   Separate interfaces for each responsibility -> Option D

4. Quick Check:

   Small focused interfaces = interface Printer { void print(); } interface Scanner { void scan(); } [OK]

Hint: Look for interfaces with single focused responsibility [OK]

Common Mistakes:

• Choosing interfaces with many unrelated methods
• Ignoring separation of concerns
• Confusing interface segregation with inheritance

3. Given these interfaces and classes, what will be the output?

interface Printer { void print(); }
interface Scanner { void scan(); }
class MultiFunctionDevice implements Printer, Scanner {
  public void print() { System.out.println("Printing document"); }
  public void scan() { System.out.println("Scanning document"); }
}

MultiFunctionDevice device = new MultiFunctionDevice();
device.print();
device.scan();

medium

A. Printing document\nScanning document

B. Printing document

C. Scanning document

D. Compilation error

Solution

1. Step 1: Understand class implementation

   The class implements both Printer and Scanner interfaces and provides both methods.

2. Step 2: Trace method calls

   Calling device.print() prints "Printing document" and device.scan() prints "Scanning document".

3. Final Answer:

   Printing document\nScanning document -> Option A

4. Quick Check:

   Both methods print messages = Printing document\nScanning document [OK]

Hint: Check which interfaces are implemented and methods called [OK]

Common Mistakes:

• Assuming only one method runs
• Expecting compilation error due to multiple interfaces
• Confusing method outputs

4. Identify the problem in this interface design violating the Interface Segregation Principle:

interface Worker {
  void work();
  void eat();
}

class Robot implements Worker {
  public void work() { System.out.println("Robot working"); }
  public void eat() { throw new UnsupportedOperationException(); }
}

medium

A. Worker interface is too broad, forcing Robot to implement unused methods.

B. Robot should implement eat() properly.

C. Robot class should not implement Worker interface.

D. No problem, this design is correct.

Solution

1. Step 1: Analyze interface methods

   The Worker interface combines work and eat methods, but Robot cannot eat.

2. Step 2: Identify violation

   Robot is forced to implement eat() which it does not support, violating Interface Segregation Principle.

3. Final Answer:

   Worker interface is too broad, forcing Robot to implement unused methods. -> Option A

4. Quick Check:

   Broad interface forcing unused methods = Worker interface is too broad, forcing Robot to implement unused methods. [OK]

Hint: Check if all interface methods apply to all implementers [OK]

Common Mistakes:

• Thinking Robot must implement eat() properly
• Believing no problem exists
• Suggesting Robot should avoid interface

5. You are designing a payment system with interfaces for different payment methods. Which design best follows the Interface Segregation Principle?

hard

A. interface Payment { void payWithCard(); void payWithCash(); void payWithCrypto(); }

B. interface CardPayment { void payWithCard(); } interface CashPayment { void payWithCash(); } interface CryptoPayment { void payWithCrypto(); }

C. interface Payment { void pay(); } class AllPayments implements Payment { void pay() { /* all methods */ } }

D. interface Payment { void payWithCard(); void payWithCash(); } class CryptoPayment implements Payment { void payWithCard() {} void payWithCash() {} }

Solution

1. Step 1: Evaluate interface segregation

   interface CardPayment { void payWithCard(); } interface CashPayment { void payWithCash(); } interface CryptoPayment { void payWithCrypto(); } splits payment methods into separate interfaces, allowing clients to implement only what they need.

2. Step 2: Compare other options

   Options A, B, and D force clients to implement methods they may not use, violating the principle.

3. Final Answer:

   Separate interfaces for each payment method -> Option B

4. Quick Check:

   Separate interfaces = interface CardPayment { void payWithCard(); } interface CashPayment { void payWithCash(); } interface CryptoPayment { void payWithCrypto(); } [OK]

Hint: Split interfaces by payment method for flexibility [OK]

Common Mistakes:

• Combining all payment methods in one interface
• Forcing classes to implement unused methods
• Ignoring interface segregation benefits