Object-Oriented Programming for MAANG Interviews

For MAANG interviews, OOP should be taught from first principles to language implementation and design trade-offs, not merely by explaining the four pillars. Interviewers assess whether you understand why OOP exists, when to use it, and its limitations alongside modern paradigms. This book is arranged in chronological learning order — fundamentals first, then advanced design and interview-level discussion.

Parts

00 — Foundations of Object-Oriented Thinking

Where OOP sits among programming paradigms, why it exists at all, and the base vocabulary (objects, classes, state, identity) everything else in this book builds on.

• 1 — Evolution of Programming Paradigms — (stub)
• 2 — Why OOP Exists — (stub)
• 3 — Objects and Classes — (stub)

01 — Core Building Blocks

The mechanical pieces a class is made of — fields, methods, constructors, visibility, and the lifecycle an object goes through from creation to collection.

• 1 — Fields and Methods — (stub)
• 2 — Access Modifiers — (stub)
• 3 — Object Lifecycle — (stub)

02 — Four Pillars of OOP

Encapsulation, abstraction, inheritance, and polymorphism — the four ideas every OOP explainer leads with, covered here at interview depth rather than as a definitions list.

• 1 — Encapsulation — (stub)
• 2 — Abstraction — (stub)
• 3 — Inheritance — (stub)
• 4 — Polymorphism — (stub)

03 — Relationships Between Objects

How objects reference and own each other — association, aggregation, composition, and dependency — and why picking the wrong one is a common design-interview trap.

• 1 — Association — (stub)
• 2 — Aggregation — (stub)
• 3 — Composition — (stub)
• 4 — Dependency — (stub)

04 — Object Design Principles

SOLID and GRASP as the two principle sets that turn “it compiles” into “it’s well designed,” plus the metrics used to measure whether a design actually got better.

• 1 — SOLID Principles — (stub) — see also SOLID Revisited in the Patterns book for the architecture-scale view.
• 2 — GRASP Principles — (stub)
• 3 — Object-Oriented Metrics — (stub)

05 — Advanced Object-Oriented Concepts

The concepts that separate “used OOP” from “understands OOP” in a senior interview — equality vs. identity, immutability, cloning semantics, and serialization pitfalls.

• 1 — Interfaces vs Abstract Classes — (stub)
• 2 — Object Equality — (stub)
• 3 — Immutability — (stub)
• 4 — Object Cloning — (stub)
• 5 — Object Serialization — (stub)

06 — Memory and Runtime

What actually happens under the hood — stack vs. heap layout, how virtual dispatch is implemented, and how garbage collectors reclaim unreachable objects.

• 1 — Memory Layout — (stub)
• 2 — Dynamic Dispatch — (stub)
• 3 — Garbage Collection — (stub)

07 — Design Patterns Through OOP

The 23 canonical Gang-of-Four patterns, grouped by intent. Full implementations and trade-offs already live in the Patterns book — these chapters are the OOP-first framing and interview lens.

• 1 — Creational Patterns — (stub) — see also Creational Patterns.
• 2 — Structural Patterns — (stub) — see also Structural Patterns.
• 3 — Behavioral Patterns — (stub) — see also Behavioral Patterns.

08 — Language-Specific OOP

How the same OOP ideas actually get implemented — and where they diverge — across Java, C#, C++, Python, and JavaScript/TypeScript.

• 1 — Java OOP — (stub)
• 2 — C# OOP — (stub)
• 3 — C++ OOP — (stub)
• 4 — Python OOP — (stub)
• 5 — JavaScript & TypeScript OOP — (stub)

09 — OOP in Large Systems

What happens to object modeling once it has to survive process boundaries, concurrent access, and years of accumulated shortcuts — DDD, distributed systems, concurrency, and anti-patterns.

• 1 — Domain-Driven Design Basics — (stub) — see also Service Decomposition.
• 2 — OOP in Distributed Systems — (stub) — see also Service Decomposition and Microservices.
• 3 — OOP and Concurrency — (stub) — see also Operating System‘s Concurrency Part and Patterns‘s Concurrency Patterns Part.
• 4 — OOP Anti-Patterns — (stub)

10 — Interview Mastery

Where everything above gets applied under interview conditions — conceptual FAQs, classic coding problems, and the OOD interview process itself.

• 1 — Frequently Asked Interview Questions — (stub)
• 2 — Coding Problems — (stub) — see also the worked case studies in Low-Level Design: Parking Lot, Elevator System, Library Management System, Vending Machine, Chess, ATM, Tic Tac Toe, and Notification Service.
• 3 — Object-Oriented Design Interviews — (stub)

11 — Appendix

Quick-reference material — UML notation, cheat sheets, a pattern-selection matrix, a language-feature comparison table, and a large interview-question bank.

• 1 — UML Class Diagrams — (stub)
• 2 — UML Sequence Diagrams — (stub)
• 3 — UML State Diagrams — (stub)
• 4 — UML Activity Diagrams — (stub)
• 5 — Common OOP Interview Pitfalls — (stub)
• 6 — OOP Cheat Sheet — (stub)
• 7 — SOLID Cheat Sheet — (stub)
• 8 — Design Pattern Selection Matrix — (stub)
• 9 — Language Feature Comparison — (stub)
• 10 — 200+ MAANG OOP Interview Questions — (stub)

Where This Fits

Study this book alongside the broader interview curriculum, not in isolation:

• Before OOP: Programming fundamentals, Data Structures, Algorithms.
• After OOP: Design Patterns, System Design, Distributed Systems, Clean Code, Refactoring, Domain-Driven Design, and Engineering Patterns.

This sequence mirrors how OOP concepts get applied in real software engineering, and how they are commonly evaluated in senior MAANG interviews.

Metadata

Author	Amit Singh
Scope	object-oriented-programming