Core Java 100% Complete Serialized Curriculum (Phases 01–20)
Authoritative 20-phase engineering syllabus strictly ordered from Language Foundations to Capstone Architectures. Grounded in Cay S. Horstmann's Core Java Volume I & II, with real workspace code from Modules 1–6, real-world analogies, step-by-step memory breakdowns, and separated Java LTS 8, 11, 17, and 21 deep dives.
Track 1: Language Foundations & OOP Design
Java Fundamentals & JVM Execution Model
Master the JVM bytecode lifecycle, strict pass-by-value proof, primitive datatypes, bitwise operations, modern switch pattern matching, and memory allocation.
Object-Oriented Programming (OOP) & Modern Class Design
Deep-dive into constructor chaining, Composition vs Aggregation, dynamic binding with vtables, and abstract classes vs interface evolution.
Strings, Object Contract & Memory Internals
Understand the String Constant Pool (SCP), immutability proofs, equals() & hashCode() 5-contract rule, and defensive copying.
Exception Handling & Diagnostic Resilience Architecture
Throwable hierarchy, Checked vs Unchecked exceptions, Try-with-resources AutoCloseable mechanics, custom checked exceptions, and java.util.logging enterprise trace levels.
Track 2: Data Structures & Generic Typing
Collections Framework & Low-Level Data Structures
Pointers vs Array memory, custom LinkedList vs java.util.LinkedList, ArrayList resizing math, HashMap treeification & collision handling, fail-fast iterators, and Comparable vs Comparator.
Generics & Compile-Time Type Safety
Master the PECS Principle (? extends Producer, ? super Consumer), Type Erasure bytecode mechanics, Type Invariance, and generic bounded repository patterns.
Track 3: The Java LTS Evolution (8, 11, 17, 21)
Java 8 LTS • Functional Interfaces, Lambdas, Method References & Streams
Master Java 8 LTS: Single Abstract Method (SAM) interfaces, Lambda syntax, Method references (static, instance, constructor Class::new), Lazy Stream pipelines, Collectors, and Optional anti-patterns.
Java 11 LTS (with 9 & 10) • var, Unmodifiable Collections, String Suite & Files API
Master Java 11 LTS (with 9 & 10): Local-Variable Type Inference (var), List.of/Map.of/Set.of unmodifiable collections, Unicode-aware strip() vs trim(), Files.writeString()/readString(), Predicate.not(), and takeWhile/dropWhile.
Java 17 LTS (with 12-16) • Sealed Classes, Records, Pattern Matching & Switch Expressions
Master Java 17 LTS (with 12-16): Sealed classes and interfaces with permits, Java 16 Records (canonical & compact constructors), Pattern Matching for instanceof, Enhanced Switch Expressions with arrow syntax, and multi-line Text Blocks.
Java 21 LTS • Virtual Threads (Project Loom), Sequenced Collections & Record Patterns
Master Java 21 LTS: High-throughput lightweight Virtual Threads (Project Loom carrier vs virtual threads), Sequenced Collections hierarchy (reversed, getFirst, getLast), and Record Patterns in switch expressions.
Track 4: Concurrency & HotSpot JVM Internals
Java Multithreading, Concurrency & Thread Synchronization
OS processes vs Java threads, thread states, race conditions & synchronized monitors, wait() & notifyAll() producer-consumer coordination, Thread.join(), ExecutorService thread pools, and deadlock diagnosis.
JVM Architecture, Memory Management & GC Tuning
Runtime data areas (Heap, Stack, Metaspace, PC), ClassLoader parent delegation security, generational GC (Eden, S0, S1, Old Gen), HotSpot collectors (G1, ZGC), and troubleshooting OutOfMemoryError.
Track 5: Enterprise Persistence, Architecture & Standards
Modern File I/O, NIO.2 & Object Serialization
Classic IO vs NIO.2 non-blocking channels and buffers, Java Serialization & transient security, serialVersionUID evolution, and avoiding BigDecimal financial precision traps.
Modern Date & Time API (java.time JSR-310) & Temporal Modeling
Immutable thread-safe temporal modeling: Instant (machine time), LocalDate / ZonedDateTime (human time), Duration vs Period, and thread-safe DateTimeFormatter.
Enterprise Persistence, JDBC & Database Architecture
JDBC architecture, PreparedStatement SQL injection defense, ACID transaction demarcation (commit & rollback), DBUtility connection pooling, and Reflection API dynamic inspection.
JPA / Hibernate ORM & Entity Relationships Architecture
Object-Relational Impedance Mismatch, Entity lifecycles (Managed, Detached, Removed), relationship mapping (@OneToMany, @ManyToOne), FetchType.LAZY vs EAGER, and N+1 query elimination.
SOLID Design Principles, GoF Patterns & Architecture
The 5 SOLID principles, GoF patterns (Singleton DCL, Factory Method, Builder, Strategy, Observer), and software modularity.
JUnit 5, Mockito & Test-Driven Development (TDD) Architecture
JUnit 5 Jupiter architecture, parameterized tests (@ValueSource, @CsvSource), assertThrows exception testing, Mockito mocks/stubs/verifications, and TDD Red-Green-Refactor.
Java Platform Module System (JPMS), Inner Class Mechanics & SonarQube Standards
module-info.java encapsulation (exports, requires, opens), inner class hidden this$0 pointer memory leaks, static nested class optimization, and SonarQube cognitive complexity rules.
Learning Stages & Enterprise Capstone Projects
The 4 Progression Stages and 5 production-grade end-to-end Enterprise Capstone Projects with architecture diagrams, HTTP diagnostic server, and complete technical specifications.