Interface Segregation Principle in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a small interface for printing only.

LLD

interface Printer {
    void [1]();
}

Drag options to blanks, or click blank then click option'

AcopyDocument

BscanDocument

CfaxDocument

DprintDocument

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing methods related to scanning or faxing instead of printing.

The method printDocument is the correct one for a Printer interface focused only on printing.

2fill in blank

medium

Complete the code to split a large interface into two smaller ones.

LLD

interface [1] {
    void printDocument();
}
interface [2] {
    void scanDocument();
}

Drag options to blanks, or click blank then click option'

APrinter

BScanner

CFaxMachine

DCopier

Attempts:

3 left

💡 Hint

Common Mistakes

Combining unrelated methods in one interface.

Using incorrect interface names.

The Printer interface should have the printDocument method, and the Scanner interface should have the scanDocument method, following the Interface Segregation Principle.

3fill in blank

hard

Fix the error in the interface segregation by choosing the correct interface name for faxing.

LLD

interface [1] {
    void faxDocument();
}

Drag options to blanks, or click blank then click option'

AScanner

BPrinter

CFaxMachine

DCopier

Attempts:

3 left

💡 Hint

Common Mistakes

Putting fax method in Printer or Scanner interfaces.

The FaxMachine interface should contain the faxDocument method to keep interfaces focused and small.

4fill in blank

hard

Fill both blanks to define interfaces for printing and scanning separately.

LLD

interface [1] {
    void printDocument();
}
interface [2] {
    void scanDocument();
}

Drag options to blanks, or click blank then click option'

APrinter

BScanner

CFaxMachine

DCopier

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same interface for both printing and scanning.

Separating printing and scanning into Printer and Scanner interfaces follows the Interface Segregation Principle.

5fill in blank

hard

Fill all three blanks to define a multi-function device implementing separate interfaces.

LLD

class MultiFunctionDevice implements [1], [2], [3] {
    public void printDocument() { /* implementation */ }
    public void scanDocument() { /* implementation */ }
    public void faxDocument() { /* implementation */ }
}

Drag options to blanks, or click blank then click option'

APrinter

BScanner

CFaxMachine

DCopier

Attempts:

3 left

💡 Hint

Common Mistakes

Implementing a single large interface instead of multiple small ones.

The class implements Printer, Scanner, and FaxMachine interfaces to follow the Interface Segregation Principle by using focused interfaces.

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