Object-Oriented Programming (Java)

Evolution of programming paradigms, procedural limitations, object-oriented concepts, and high-level software modeling.

• Unit 1 — Introduction to OOP & Programming Paradigms — Chapter PDF
• Lesson 1 — Programming Paradigms & The Software Evolution
• Lesson 2 — The Core Pillars of Object-Oriented Engineering

Detailed exploration of JVM runtime architecture, bytecode execution, primitive vs reference types, control flow compilation, String immutability, and array memory layout.

• Unit 2 — Java Basics, JVM Architecture & Memory Model — Chapter PDF
• Lesson 1 — The JVM Architecture, Execution Pipeline & Memory Foundations
• Lesson 2 — Control Structures, Short-Circuit Evaluation & Bytecode Branching
• Lesson 3 — Strings, Array Memory Layout & Standard Library Utilities

Deep dive into class specifications, runtime object instantiation, memory lifecycles, encapsulation boundaries, constructor chaining, static vs virtual method dispatch, and modular packages.

• Unit 3 — Classes, Objects, Methods & Constructors — Chapter PDF
• Lesson 1 — Class Anatomy, Object Instantiation & Memory Lifecycle
• Lesson 2 — Encapsulation, Access Control & The Initialization Lifecycle
• Lesson 3 — Static Members, Method Overloading & Modular Package Architecture

Comprehensive examination of inheritance mechanics, dynamic method dispatch via vtables, Liskov Substitution Principle, abstract classes vs modern interfaces, and the final modifier.

• Unit 4 — Inheritance, Polymorphism & Abstract Classes / Interfaces — Chapter PDF
• Lesson 1 — Inheritance Mechanics, The Diamond Problem & super() Lifecycle
• Lesson 2 — Dynamic Polymorphism, Method Overriding & Virtual Method Tables (vtables)
• Lesson 3 — Abstract Classes vs Interfaces & Modern Contract Architecture

Advanced examination of dynamic binding, polymorphic dispatch, heterogeneous collections, the Open-Closed Principle, type casting, modern pattern matching, and array covariance.

• Unit 5 — Polymorphism, Dynamic Binding & Type Systems — Chapter PDF
• Lesson 1 — Late Binding, Dynamic Dispatch & Heterogeneous Collections
• Lesson 2 — Type Casting Mechanics, Pattern Matching & Covariance Pitfalls

In-depth investigation of Java exception handling runtime, the Throwable hierarchy, call stack unwinding, try-with-resources, custom domain exceptions, and fault-tolerant architecture.

• Unit 6 — Exception Handling & Fault-Tolerant Systems — Chapter PDF
• Lesson 1 — The Java Exception Hierarchy, Call Stack Unwinding & Checked vs. Unchecked Contracts
• Lesson 2 — Exception Control Flow: Try-Catch-Finally, Throw/Throws & Clean Resource Management
• Lesson 3 — Enterprise Exception Architecture: Custom Domain Exceptions, Chaining & Anti-Patterns

Mastering modern Java desktop GUI architecture: JavaFX Scene Graph, responsive layout panes, the delegation event handling model, reactive property binding, and desktop MVC design patterns.

• Unit 7 — Graphical User Interfaces (GUI) & Event-Driven Architecture — Chapter PDF
• Lesson 1 — JavaFX Architecture, The Scene Graph & Core UI Controls
• Lesson 2 — Modern Layout Architectures: Panes, Constraints & Responsive GUI Design
• Lesson 3 — The Delegation Event Model, Reactive Handlers & Enterprise MVC Architecture