Low-Level Design & Design Patterns

A hands-on refresher on encapsulation, inheritance, abstraction, polymorphism, and composition, plus the UML notation used to diagram class relationships throughout this course.

Why bundling unrelated jobs onto one class creates hidden coupling, and how splitting a class along its true axes of change keeps each piece independently safe to modify.

Why growing an if/else chain every time a new case appears is a design smell, and how to make a class open to new behavior without ever reopening its already-tested code.

Why a subclass that compiles cleanly can still be an unsafe substitute for its parent, and how to design hierarchies where every subtype genuinely honors its parent's contract.

Why bundling unrelated capabilities into one large interface forces implementers to fake support for things they can't do, and how splitting by capability fixes it.

Why hardwiring a high-level class to a low-level implementation makes testing and extension painful, and how depending on a shared abstraction instead makes both sides swappable.

Learn how to add undo functionality to an object without exposing its internal state, by splitting the work across an Originator, an opaque Memento snapshot, and a Caretaker that manages history.

Learn to decouple a data source from everything that reacts to it, by having any number of independent listeners subscribe to a shared notification contract instead of being hardwired in.

Learn to pull a varying algorithm out of an if/else chain into a family of interchangeable classes, so a new behavior can be added as one new class with zero changes to existing, tested code.

Learn to turn a request into a self-contained, queueable object with a standard execute() method, so an invoker like a UI button can trigger any action without knowing what it does.

Learn to lock a fixed sequence of steps in a base class while letting subclasses fill in exactly one varying step, eliminating duplicated boilerplate across similar classes.

Learn to expose a uniform way to walk through a collection's elements without leaking its internal storage structure to client code, the same mechanism behind every Java for-each loop.

Learn how to replace scattered switch statements with self-contained state classes, so an object's behavior changes cleanly as its internal state changes.

Learn how introducing one central coordinator collapses a tangled web of objects that all reference each other directly into a simple hub-and-spoke design, using a group chat as the running example.

Learn how to guarantee a class has exactly one instance application-wide, why the naive version breaks under concurrency, and why Singleton has a genuinely bad reputation despite being useful.

Learn how to hide the decision of which concrete class to instantiate behind one dedicated method, so callers can request an object by type without ever writing new on a concrete class themselves.

Learn how to guarantee that a whole family of related objects is created consistently together, using a cross-platform UI kit where a button and a scroll bar must always match the same theme.

Learn how to construct a complex object with many optional parameters step by step and readably, avoiding both a dangerous positional constructor and combinatorial constructor explosion.

Learn how the Prototype pattern lets an object clone itself instead of forcing client code to rebuild it field by field, and why the shallow-copy versus deep-copy decision is the whole point of the pattern.

Learn how the Adapter pattern lets an application keep using the interface it already depends on while swapping out the concrete implementation behind it, without touching a single existing call site.

Learn how the Decorator pattern adds optional, combinable behavior to an individual object at runtime by wrapping it, avoiding the combinatorial subclass explosion that inheritance-based designs run into.

Learn how the Proxy pattern lets a stand-in object control when an expensive real object actually gets created, enabling lazy loading and caching without the client ever knowing the difference.

Learn how the Composite pattern lets a single leaf object and an entire branch of a tree be treated through one identical interface, so operations like a recursive file-system walk fall out naturally with no type-checking.

Learn how the Facade pattern hides a multi-step coordination sequence across several subsystems behind one simple method, so client code stops needing to know every subsystem exists.

Learn how to share data across thousands of near-identical objects instead of duplicating it, using a multiplayer shooter's bullets as the running example.

Three more classic design patterns, each solving a distinct problem: decoupling two independently varying hierarchies, adding new operations without touching existing classes, and letting a request pass along a chain of handlers until one can process it.

A full interview-style system design walkthrough: build a ride-sharing app the obvious way, find its real bugs and SOLID violations, then refactor it end to end using Strategy, Observer, and Mediator together.