⚡ Stack.Java — 0 to 100

A linear, self-contained curriculum — 101 modules — from zero Java to intermediate/advanced.

---

📋 Overview

Stack.Java is a strictly linear, zero-dependency curriculum designed for developers who already know at least one programming language (Python, JavaScript, C, etc.) and want to go from zero Java knowledge to intermediate/advanced Java proficiency.

No build tools. No site generators. No fluff. Just plain Markdown lessons, runnable code examples, practice exercises with solutions, and a quiz per module — all requiring nothing more than a terminal and JDK 21.

Who this is for: Developers who know programming basics but are new to Java. Explanations focus on what makes Java unique — static typing, JVM, checked exceptions, the collections framework — without re-teaching universal programming concepts.

---

🔧 Prerequisites

Requirement	Details
JDK 21 LTS	Several modules cover records, sealed classes, and pattern matching — all require modern Java. Download from Adoptium or your package manager.
Verify installation	Run java -version — you should see version 21 or later.
IDE (optional)	IntelliJ IDEA Community Edition or VS Code with Java extensions recommended for syntax highlighting and navigation, but any text editor + terminal works.

---

🚀 How to Use This Repo

Modules must be completed in strict order — each builds on the one before it.

Per-Module Workflow

┌─────────────────────────────────────────────────────────────┐
│  ① Read the lesson     →   ② Run the examples               │
│                                                             │
│  ③ Do the exercises    →   ④ Check your work               │
│                                                             │
│  ⑤ Take the quiz       →   ⑥ Move to the next module       │
└─────────────────────────────────────────────────────────────┘

1. Read README.md — the lesson with theory, code walkthroughs, and a quiz.
2. Run the examples — navigate to examples/, compile and run each .java file.
3. Do the exercises — open exercises/README.md and attempt every problem.
4. Check your work — compare against the files in solutions/.
5. Take the quiz — at the bottom of each README.md, then check your answers.
6. Repeat for the next module.

Compile & Run Any Example

cd module-X-topic-name/examples
javac ExampleName.java
java ExampleName

All examples and solutions use no package declarations (except the dedicated packages module), so they compile with a single javac command and run with a single java command.

---

📊 Curriculum Overview — 14 Phases, 101 Modules

Phase	Modules	Focus
1	00–03	Introduction & Setup
2	04–19	Core Language Fundamentals
3	20–38	Object-Oriented Programming
4	39–44	Exception Handling & Generics
5	45–53	Collections Framework
6	54–60	Functional Java
7	61–68	I/O and Concurrency
8	69–72	Databases & Networking
9	73–74	Tooling & Testing
10	75–80	Design & Architecture
11	81–86	Modern Java Features
12	87–91	GUI Programming
13	92–95	Introduction to Spring
14	96–100	Professional Practices & Capstone

---

📚 Full Table of Contents

Phase 1 — Introduction & Setup (Modules 0–3)

#	Module
00	Introduction to Java — History, Philosophy, and Applications
01	Setting Up Your Environment (JDK, JAVA_HOME, javac/java, IDE options)
02	Your First Java Program (Hello World, anatomy of a class and main)
03	Java Syntax Basics, Comments, and Program Structure

Phase 2 — Core Language Fundamentals (Modules 4–19)

#	Module
04	Variables and Primitive Data Types
05	Type Casting and Conversion
06	Operators (Arithmetic, Relational, Logical, Bitwise, Assignment)
07	Reading Input from the Console (Scanner)
08	Strings and String Methods
09	StringBuilder and StringBuffer
10	Conditional Statements (if/else, switch)
11	Loops (for, while, do-while)
12	Enhanced for-loop, break, continue, and Labeled Loops
13	Arrays (One-Dimensional)
14	Multidimensional Arrays
15	The Arrays Utility Class
16	Methods — Declaration, Parameters, and Return Values
17	Method Overloading
18	Variable Scope and an Intro to Stack vs Heap Memory
19	Recursion

Phase 3 — Object-Oriented Programming (Modules 20–38)

#	Module
20	Introduction to Object-Oriented Programming Concepts
21	Classes and Objects
22	Constructors
23	The this Keyword
24	Access Modifiers (public, private, protected, default)
25	Encapsulation
26	The static Keyword (fields, methods, blocks)
27	Inheritance Basics
28	The super Keyword and Method Overriding
29	Polymorphism
30	Abstract Classes
31	Interfaces
32	Interfaces vs Abstract Classes; Default and Static Interface Methods
33	Object Class Methods (equals, hashCode, toString)
34	Packages and Imports
35	The final Keyword
36	Enums
37	Nested and Inner Classes
38	Anonymous Classes

Phase 4 — Exception Handling & Generics (Modules 39–44)

#	Module
39	Exception Handling Basics (try/catch/finally)
40	Checked vs Unchecked Exceptions; throw and throws
41	Custom Exceptions
42	try-with-resources
43	Generics Basics
44	Bounded Generics and Wildcards

Phase 5 — Collections Framework (Modules 45–53)

#	Module
45	Collections Framework Overview
46	The List Interface (ArrayList, LinkedList)
47	The Set Interface (HashSet, LinkedHashSet, TreeSet)
48	The Map Interface (HashMap, LinkedHashMap, TreeMap)
49	Queue and Deque
50	Iterator, Comparable, and Comparator
51	The Collections Utility Class
52	Autoboxing, Unboxing, and Wrapper Classes
53	Immutability and the String Pool

Phase 6 — Functional Java (Modules 54–60)

#	Module
54	Lambda Expressions
55	Functional Interfaces
56	Method References
57	Streams API Basics
58	Streams — Intermediate/Terminal Operations and Collectors
59	The Optional Class
60	The Date and Time API (java.time)

Phase 7 — I/O and Concurrency (Modules 61–68)

#	Module
61	File I/O Basics (File class, reading/writing files)
62	Java NIO Basics
63	Serialization
64	Multithreading Basics (Thread, Runnable)
65	Thread Lifecycle and Synchronization
66	Executors and Thread Pools
67	Concurrent Collections and Atomic Classes
68	CompletableFuture and Asynchronous Programming

Phase 8 — Databases & Networking (Modules 69–72)

#	Module
69	JDBC Basics — Connecting to a Database
70	JDBC CRUD Operations
71	Networking Basics (Sockets)
72	The Java HTTP Client

Phase 9 — Tooling & Testing Concepts (Modules 73–74)

#	Module
73	Introduction to Build Tools (Maven and Gradle, Conceptual Overview)
74	Unit Testing Concepts with JUnit

Phase 10 — Design & Architecture (Modules 75–80)

#	Module
75	Design Patterns I — Singleton and Factory
76	Design Patterns II — Builder and Observer
77	Design Patterns III — Strategy and Decorator
78	SOLID Principles
79	The Java Memory Model and Garbage Collection
80	JVM Internals — Class Loading and Bytecode

Phase 11 — Modern Java Features (Modules 81–86)

#	Module
81	The Reflection API
82	Annotations
83	Records (Java 16+)
84	Sealed Classes (Java 17+)
85	Pattern Matching (instanceof and switch expressions)
86	The Java Platform Module System (JPMS)

Phase 12 — GUI Programming (Modules 87–91)

#	Module
87	Introduction to GUI Programming — Swing Basics
88	Swing — Layouts and Event Handling
89	JavaFX Basics
90	JavaFX — FXML and Styling
91	Mini Project: Building a Simple JavaFX Desktop App

Phase 13 — Introduction to Spring (Modules 92–95)

#	Module
92	Introduction to the Spring Framework and Dependency Injection
93	Spring Boot Basics — Setting Up a Project
94	Spring Boot — Building REST APIs
95	Spring Boot — Connecting to a Database with Spring Data JPA

Phase 14 — Professional Practices & Capstone (Modules 96–100)

#	Module
96	Logging in Java (java.util.logging and the SLF4J Concept)
97	Best Practices and Clean Code in Java
98	Debugging Techniques and Tools
99	Capstone Project Part 1 — Planning and Building a Console Application
100	Capstone Project Part 2 — Polishing the Capstone and Where to Go Next

---

🎯 What You'll Learn

Area	Details
Java Language	Syntax, OOP, generics, enums, records, sealed classes, pattern matching
Core APIs	Collections, streams, lambdas, date/time, I/O, NIO, networking
Concurrency	Threads, executors, synchronized, CompletableFuture, concurrent collections
Professional Tools	JUnit testing, logging, build tools (conceptual), debugging, clean code
GUI Programming	Swing basics, JavaFX with FXML and styling
Spring Boot	DI, REST APIs, Spring Data JPA (introductory)
JVM Internals	Memory model, garbage collection, class loading, bytecode, reflection
Design & Architecture	Patterns (Singleton, Factory, Builder, Observer, Strategy, Decorator), SOLID principles
Capstone Project	Plan, build, and refine a full console application applying everything learned

---

🏁 Where to Go After Module 100

Congratulations on completing all 101 modules. Here are logical next steps to continue your Java journey:

Path	Description
Kotlin	A modern JVM language that interoperates seamlessly with Java; official language for Android development.
Android Development	Build mobile apps using Java or Kotlin with Android Studio.
Spring Ecosystem	Deep dive into Spring Cloud, Spring Security, Spring Reactive (WebFlux), and Spring Batch.
Microservices	Service discovery, API gateways, distributed tracing, Docker, and Kubernetes.
Open Source Java	Contribute to Spring Boot, Hibernate, Apache Kafka, Elasticsearch, or the OpenJDK itself.
JVM Languages	Explore Scala, Clojure, or Groovy to see different paradigms on the same runtime.

---

_{Built with ☕ and Markdown. Licensed under MIT.}