OOP and SOLID
22 interview questions and answers in the OOP and SOLID section.
Questions in this section
- What is Single Responsibility Principle and How to Apply It
- Give an Example of Single Responsibility Principle Violation
- What is Open-Closed Principle?
- How to Refactor Code that Violates Open-Closed Principle?
- What is Liskov Substitution Principle?
- Give an Example of Liskov Substitution Principle Violation
- What is Interface Segregation Principle?
- What is Dependency Inversion Principle?
- Why Do We Need SOLID Principles at All?
- What is Composition and Inheritance
- When Is It Better to Use Composition Instead of Inheritance
- What is Delegation in OOP
- How is Single Responsibility Related to Cohesion
- What Happens if a Class Has Multiple Reasons to Change
- How Does SOLID Help in Code Testing?
- How is Dependency Inversion Related to Dependency Injection?
- What is Law of Demeter (Principle of Least Knowledge)?
- How to Refactor God Object?
- How Do SOLID Principles Help When Extending Functionality?
- Can You Follow All SOLID Principles at Once?
- How to Determine if a Class Has Single Responsibility?
- What Anti-patterns Contradict SOLID Principles?
Study navigator
22 questions for preparing for a Middle Java Developer interview.
📋 All Questions
🗺️ Topic Dependency Map
┌──────────────────────────────────────────┐
│ SOLID BASICS (1-9) │
│ 1-2. SRP (what + violation example) │
│ 3-4. OCP (what + refactoring) │
│ 5-6. LSP (what + violation example) │
│ 7. ISP │
│ 8. DIP │
│ 9. Why SOLID │
└──────────────────┬───────────────────────┘
│
┌──────────────────────────┼──────────────────────────┐
▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌────────────────────┐
│ COMPOSITION │ │ DEEPER │ │ PRACTICE │
│ AND INHERIT. │ │ SRP/DIP │ │ AND ANTI-PATTERNS │
│ (10-12) │ │ (13-16) │ │ (17-22) │
│ 10. Composition│ │ 13. SRP + │ │ 17. Law of Demeter │
│ 11. When which│ │ cohesion │ │ 18. God Object │
│ 12. Delegat. │ │ 14. Multiple │ │ 19. Extending │
│ │ │ reasons │ │ 20. All SOLID at once│
│ │ │ 15. Testing │ │ 21. How to determine│
│ │ │ 16. DIP vs DI │ │ 22. Anti-patterns │
└───────────────┘ └───────────────┘ └────────────────────┘
🎯 Recommended Study Order
🟢 Junior Level (weeks 1-2)
| Step | Topic | Files | Goal |
|---|---|---|---|
| 1 | SOLID overview | Q9 | Why we need principles |
| 2 | SRP | Q1, Q2 | Single responsibility, violation examples |
| 3 | OCP | Q3 | Open for extension, closed for modification |
| 4 | Composition vs inheritance | Q10, Q11 | Why composition is preferred |
| 5 | Delegation | Q12 | How delegation works |
🟡 Middle Level (weeks 3-4)
| Step | Topic | Files | Goal |
|---|---|---|---|
| 1 | LSP | Q5, Q6 | Substitutability of subclasses, violation examples |
| 2 | ISP | Q7 | Don’t force implementing unnecessary methods |
| 3 | DIP | Q8, Q16 | Dependency on abstractions, relation to DI |
| 4 | SRP + Cohesion | Q13 | How SRP affects cohesion |
| 5 | Consequences of violation | Q14, Q15 | What happens with SRP violation, how SOLID helps testing |
| 6 | Law of Demeter | Q17 | Principle of least knowledge |
🔴 Senior Level (weeks 5-6)
| Step | Topic | Files | Goal |
|---|---|---|---|
| 1 | OCP Refactoring | Q4 (Senior) | Strangler Fig, Strategy, Visitor, SPI |
| 2 | God Object Refactoring | Q18 | Progressive refactoring, Bounded Contexts |
| 3 | SOLID Trade-offs | Q20 | When SOLID conflicts with itself |
| 4 | Determining SRP | Q21 | Stakeholder analysis, cross-cutting concerns |
| 5 | Anti-patterns | Q22 | STUPID mnemonic, Speculative Generality |
| 6 | Extending Functionality | Q19 | YAGNI, Strangler Fig |
🔗 Key Connections Between Topics
Topic: SOLID Principles
Q9 (Why SOLID) → Q1 (SRP) → Q3 (OCP) → Q5 (LSP) → Q7 (ISP) → Q8 (DIP)
↓
Q13 (SRP+Cohesion) → Q14 (Multiple reasons) → Q15 (Testing)
Key connections:
- Q9 ↔ Q22: SOLID protects against STUPID anti-patterns
- Q1 ↔ Q13: SRP → high cohesion → lower LCOM
- Q3 ↔ Q4: OCP concept → refactoring to OCP
- Q5 ↔ Q6: LSP theory → concrete violation examples (Date, SavingsAccount)
Topic: Composition and Inheritance
Q10 (Composition vs inheritance) → Q11 (When which) → Q12 (Delegation)
Key connections:
- Q10 ↔ Q11: Concept → practical selection rules
- Q11 ↔ Q8: Composition → DIP (depend on interface, not implementation)
- Q12 ↔ Q10: Delegation = mechanism of composition
Topic: Practice and Anti-patterns
Q17 (Law of Demeter) → Q18 (God Object) → Q22 (Anti-patterns)
↓ ↓
Q19 (Extending) → Q20 (All SOLID) → Q21 (How to determine SRP)
Key connections:
- Q17 ↔ Q18: Train Wreck → God Object → refactoring
- Q18 ↔ Q22: God Object — one of the STUPID anti-patterns
- Q19 ↔ Q4: Extending functionality → OCP refactoring
- Q20 ↔ Q9: SOLID trade-offs → why we need them
🎓 Cheat Sheet: What to Know for Each Level
🟢 Junior
- SRP: one reason to change = one stakeholder
- OCP: add new classes, don’t modify old ones
- Composition > inheritance: has-a is better than is-a
- DIP: depend on interfaces, not implementations
- ISP: don’t force implementing unnecessary methods
🟡 Middle
- LSP: subclass must not strengthen preconditions or weaken postconditions
- Cohesion: SRP → high cohesion, LCOM metric
- Law of Demeter: don’t talk to strangers (a.b.c() = Train Wreck)
- DI vs DIP: DI is a mechanism, DIP is an architectural rule
- Delegation: black box, only public interface
🔴 Senior
- OCP refactoring: Strangler Fig, Strategy, Visitor, SPI
- God Object refactoring: Progressive refactoring, Bounded Contexts, Saga
- SOLID trade-offs: when principles conflict (SRP vs DIP, OCP vs YAGNI)
- Megamorphic calls: 3+ interface implementations → performance degradation
- Sealed interface (Java 17+): pattern matching, compiler guarantees exhaustiveness
- STUPID: Singleton, Tight Coupling, Premature Optimization, Indescriptive Naming, Duplication
📝 File Format
Each file contains:
- 🟢 Junior Level — basic understanding, simple analogies, examples
- 🟡 Middle Level — internals, common mistakes, practical examples
- 🔴 Senior Level — deep dive, edge cases, production experience, monitoring
- 🎯 Interview Cheat Sheet — key points, common questions, red flags, related topics