Course Overview & Running Example

What this Object-Oriented Programming course covers, how to use it, prerequisites, and the running example used throughout.

Course Overview

This course takes you from "what is a class?" to designing extensible systems with patterns, SOLID, clean architecture and domain-driven design — and it is honest about where object orientation helps and where it gets in the way.

Stage 1 — Beginner (Modules 1–9): paradigms, classes and objects, encapsulation, abstraction, constructors, the four pillars, inheritance, polymorphism and object relationships.

Stage 2 — Intermediate (Modules 10–25): language mechanics (static members, this/super, copy and move, memory, exceptions, overloading, operators, generics, value objects), design principles (SOLID, DRY/KISS/YAGNI, coupling and cohesion, dependency injection) and UML/OOAD.

Stage 3 — Advanced (Modules 26–54): all 23 classic design patterns plus enterprise and resilience patterns, code smells and refactoring.

Stage 4 — Expert (Modules 55–89): object layout and dispatch, reflection, metaprogramming, functional OOP, concurrency, async, persistence, API design, testing, security, reliability, performance, architecture (layered, hexagonal, clean, DDD, event-driven), five language tracks, projects and interview preparation.

How to Use This Course

Every module follows the same template so you always know where to look:

Learning Objectives and prerequisites Intuition and Definition — the idea in plain words, then the precise definition Why It Matters

Syntax and Language Notes — C++ first, with tabs for Java, C#, Python and TypeScript where the languages differ

Complete Example with its Expected Output Step-by-Step Walkthrough, with a diagram where it helps Common Mistakes Trade-offs and Alternatives Real-World Use

Practice — easy, medium and advanced exercises with worked answers

Interview Question — a tricky question with a full solution

Quick Quiz and Summary with related modules

How the Examples Were Verified

No output in this course was typed by hand. Every complete program was compiled and run, and the text you see under *Expected Output* is what the program actually printed:

Toolchain used to run the examples clang 21.1 with libc++ 21 (zig c++ -std=c++23 -O1 -Wall -Wextra, assert enabled), x86-64 Windows

Node.js 24 (runs .ts files directly by stripping the types).NET 10 SDK (dotnet run Program.cs)

Not available on the build machine — Java snippets are shown for comparison and marked *not run*

Where a result depends on the compiler or platform (object sizes, typeid names, timing), the text says so. Programs that are *supposed* to fail to compile show the real compiler error.

Prerequisites

Comfortable with one programming language: variables, functions, loops, arrays.

For the C++ examples: basic syntax (#include, std::cout, references). Pointers and templates are explained when they first matter.

No prior OOP knowledge is assumed.

The Running Example

Many modules return to the same small domain so that you can watch a design evolve: an automotive instrument cluster — sensors (speed, coolant temperature, fuel), warnings, display modes and a diagnostic log — plus everyday domains such as bank accounts, shopping carts, libraries and parking lots. The cluster examples illustrate OOP; they are not a substitute for real functional-safety processes (ISO 26262), which the course points out where relevant.