SOLID violations and fixes in LLD - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the Single Responsibility Principle (SRP) state?

SRP means a class should have only one reason to change, meaning it should have only one job or responsibility.

intermediate

What is a common violation of the Open/Closed Principle (OCP)?

Changing existing code to add new features instead of extending it. This makes the system fragile and hard to maintain.

intermediate

How can the Liskov Substitution Principle (LSP) be violated?

When a subclass changes the expected behavior of the parent class, causing errors when used in place of the parent.

beginner

What does the Interface Segregation Principle (ISP) recommend?

Clients should not be forced to depend on interfaces they do not use. Use many small, specific interfaces instead of one large one.

intermediate

How does the Dependency Inversion Principle (DIP) improve design?

By depending on abstractions (interfaces) rather than concrete classes, making the system flexible and easier to change.

Which SOLID principle is violated if a class handles multiple unrelated tasks?

A Liskov Substitution Principle

B Open/Closed Principle

C Single Responsibility Principle

D Dependency Inversion Principle

A class with multiple unrelated tasks violates SRP because it has more than one reason to change.

What is a fix for violating the Open/Closed Principle?

A Extend classes using inheritance or composition

B Modify existing classes for new features

C Remove interfaces

D Use global variables

Extending classes allows adding new features without changing existing code, respecting OCP.

If a subclass breaks the behavior expected from its parent, which principle is violated?

A Interface Segregation Principle

B Liskov Substitution Principle

C Dependency Inversion Principle

D Single Responsibility Principle

LSP requires subclasses to be substitutable for their parents without altering expected behavior.

What does Interface Segregation Principle encourage?

A Many small, specific interfaces

B One large interface for all clients

C No interfaces at all

D Using abstract classes only

ISP encourages small, focused interfaces so clients only depend on what they use.

Dependency Inversion Principle suggests depending on:

A Concrete classes

B Static methods

C Global variables

D Abstractions (interfaces)

DIP promotes depending on abstractions to reduce coupling and increase flexibility.

Explain how you would fix a class that violates the Single Responsibility Principle.

Think about dividing jobs like splitting household chores among family members.

Describe how the Dependency Inversion Principle helps in making a system easier to maintain.

Imagine using a universal remote that works with many devices instead of a fixed one.

Practice

1. Which SOLID principle is violated if a class has too many responsibilities, making it hard to maintain?

easy

A. Single Responsibility Principle

B. Open/Closed Principle

C. Liskov Substitution Principle

D. Interface Segregation Principle

Solution

1. Step 1: Understand the problem of multiple responsibilities

   A class with many responsibilities is hard to maintain and change because changes in one responsibility may affect others.

2. Step 2: Identify the violated SOLID principle

   The Single Responsibility Principle states that a class should have only one reason to change, meaning one responsibility.

3. Final Answer:

   Single Responsibility Principle -> Option A

4. Quick Check:

   One class, one responsibility = C [OK]

Hint: One class, one job means Single Responsibility Principle [OK]

Common Mistakes:

• Confusing Single Responsibility with Open/Closed Principle
• Thinking Liskov Substitution relates to responsibilities
• Mixing Interface Segregation with class responsibilities

2. Which of the following code snippets correctly applies the Open/Closed Principle by allowing extension without modification?
class Shape {
draw() { /* draw shape */ }
}
class Circle extends Shape {
draw() { /* draw circle */ }
}

easy

A. Adding new shape classes by extending Shape without changing existing code

B. Modifying the Shape class draw method to handle all shapes

C. Using a single class for all shapes with if-else inside draw

D. Changing Circle class to override Shape's draw method with new logic

Solution

1. Step 1: Understand Open/Closed Principle

   This principle says software entities should be open for extension but closed for modification.

2. Step 2: Analyze the code snippet

   Extending Shape with new classes like Circle adds new behavior without changing existing Shape code.

3. Final Answer:

   Adding new shape classes by extending Shape without changing existing code -> Option A

4. Quick Check:

   Extend without modify = A [OK]

Hint: Extend classes, don't change existing ones [OK]

Common Mistakes:

• Modifying base class instead of extending
• Using if-else inside methods to handle new cases
• Overriding methods incorrectly causing side effects

3. Given the following code violating Interface Segregation Principle, what is the output when calling robot.work()?

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

medium

A. No output

B. UnsupportedOperationException thrown

C. Compilation error

D. Robot working

Solution

1. Step 1: Understand the code behavior

   The robot class implements work() by printing "Robot working" and eat() throws an exception.

2. Step 2: Analyze the method called

   Only robot.work() is called, which prints the message without error.

3. Final Answer:

   Robot working -> Option D

4. Quick Check:

   Calling work() prints message = A [OK]

Hint: Calling only implemented methods avoids exceptions [OK]

Common Mistakes:

• Assuming eat() is called causing exception
• Thinking interface violation causes compile error
• Ignoring method actually called in code

4. Identify the main problem in this code violating Liskov Substitution Principle:

class Bird {
  void fly() { System.out.println("Flying"); }
}
class Ostrich extends Bird {
  void fly() { throw new UnsupportedOperationException(); }
}

medium

A. Bird class should not have fly method

B. Ostrich should override fly with different signature

C. Ostrich cannot replace Bird without breaking behavior

D. No violation, code is correct

Solution

1. Step 1: Understand Liskov Substitution Principle

   Subtypes must be replaceable for their base types without altering correctness.

2. Step 2: Analyze Ostrich behavior

   Ostrich throws exception on fly(), breaking expected behavior of Bird.

3. Final Answer:

   Ostrich cannot replace Bird without breaking behavior -> Option C

4. Quick Check:

   Subtype must behave like base = B [OK]

Hint: Subtype must not break base class behavior [OK]

Common Mistakes:

• Thinking method signature change fixes violation
• Ignoring exception breaking substitution
• Assuming base class design is wrong here

5. You have a payment system where the PaymentProcessor interface has methods payWithCreditCard(), payWithPayPal(), and payWithCrypto(). A new payment method is added, but many classes implementing this interface do not support all methods, causing empty or error implementations. How should you fix this design following SOLID principles?

hard

A. Remove unsupported methods from implementations silently

B. Split the interface into smaller ones for each payment method

C. Keep one interface and add flags to check supported methods

D. Add default empty implementations to the interface methods

Solution

1. Step 1: Identify the violated principle

   Having one interface with many methods causes classes to implement unsupported methods, violating Interface Segregation Principle.

2. Step 2: Apply the fix

   Splitting the interface into smaller, specific interfaces lets classes implement only what they support, improving design.

3. Final Answer:

   Split the interface into smaller ones for each payment method -> Option B

4. Quick Check:

   Small interfaces, no unused methods = D [OK]

Hint: Use many small interfaces, not one big one [OK]

Common Mistakes:

• Adding empty default methods hides design flaws
• Using flags complicates code and violates design
• Removing methods silently breaks interface contract