Java

Module 1: Language and OOP

Core Java

Three months only works if the language is a habit. You start with types, control flow, and objects you can draw on a whiteboard.

Syntax that ships

• Types, methods, packages, and a main you can run from the CLI
• Exceptions you handle instead of swallowing
• A tiny Maven/Gradle project from day one

OOP in practice

• Encapsulation, inheritance, and composition — pick the cheaper one
• Interfaces vs abstract classes on a real example
• Equals/hashCode when you put objects in a Set

Tooling

• JDK, IDE, and why ‘it works in my run config’ is not a build
• Checkstyle-lite: readable names, no 400-line classes
• Git: commits that say what the code does

What this is not

• Not Spring yet
• Not a frontend course
• Not a 12-month diploma dump

You leave with a small OOP kata in a real build file, runnable from a cold clone.

Module 2: Collections, I/O, JDBC

Core Java

Most Java interviews still live here. You will use lists, maps, files, and a database without an ORM hiding the SQL.

Collections

• List, Set, Map — pick by access pattern
• Iteration, sorting, and ConcurrentModification surprises
• When a stream helps and when a loop is honest

I/O and JSON

• Files, charset, and resources that close
• JSON in/out without a framework maze
• Config as a file, not hardcoded strings

JDBC

• Connections, prepared statements, transactions
• A DAO you could explain to a DBA
• SQL injection as a bug you refuse to ship

Tests

• JUnit for the DAO
• A fixture database or testcontainers-shaped thinking
• A failure that taught you the grain of the table

You leave with a JDBC-backed CRUD plus tests — no Spring required yet.

Module 3: REST with Spring Boot

Spring Boot

Now the framework. You wrap the domain in HTTP: controllers, DTOs, validation, and errors that are JSON.

Boot basics

• Starters, application.yml, profiles
• A health endpoint
• Secrets in env, not in git

REST

• Resources, status codes, and idempotent PUT vs accidental POST
• Validation annotations that match the contract
• Problem details instead of a stack trace in the browser

Layering

• Controller → service → repository without a 2,000-line God class
• DTOs vs entities — do not leak JPA out the door
• Pagination when the table grows

Docs

• OpenAPI/Swagger you would show a frontend teammate
• A README: how to run, what port, what DB

You leave with a REST API and a contract a frontend (or Postman) can hit.

Module 4: JPA and persistence

Spring Boot

JPA is useful until it is magic. You will map entities, write queries you can explain, and catch N+1 before it is production.

Mapping

• Entities, IDs, relations (one-to-many without a cartoon)
• Lazy vs eager — measure, do not guess
• Flyway/Liquibase-shaped migrations as an idea

Queries

• Derived queries vs JPQL vs native when SQL is the truth
• Transactions: where they start
• Indexes you mention in the review

Failure modes

• N+1, detached entities, dirty sessions
• A log of SQL during a request
• Rollback on a failed write

Security-lite

• AuthN at a filter or Spring Security starter level
• Do not return password hashes
• CORS only if a browser UI needs it

You leave with JPA mappings plus a note on the SQL Hibernate actually ran.

Module 5: Tests and capstone

Spring Boot

The capstone is a small Spring service you can walk through: domain, API, persistence, tests.

Testing

• Slice tests vs a few integration tests
• Testcontainers or an H2 you do not treat as production
• A failing test you keep

Capstone

• One bounded domain (orders, tickets, or catalog)
• README + architecture sketch
• A 3-minute defense script

Career call

• What you would not ship to a bank tomorrow
• Java vs Frontend vs DevOps — which next
• Fee and duration as published

Boundaries

• Not Android
• Not Kafka-as-the-whole-course
• Not a fake CTC

You leave with a GitHub-ready Spring Boot service, tests, and a walkthrough.