RizTech Academy logo
RizTech Academy

Java Complete Foundation

The language running most enterprise backends in India. Learn modern Java, not the Java taught in 2010.

Java is still what most large Indian employers run, and knowing it well opens more doors than any other single language on this list.

The problem is that most Java teaching is stuck a decade back — raw loops, no streams, no records, and boilerplate that modern Java no longer needs. You end up writing code that works but marks you as inexperienced.

This course teaches Java as it is written today — on Java 21, the long-term support release most teams have standardised on — while still explaining the older style so you can read legacy code when you meet it.

It ends with a capstone of its own: a command-line tracker for a Pune tiffin service — subscriptions, daily deliveries and a month-end report — built with Maven, tested with JUnit, and packaged into a jar you can hand to somebody.

Who this is for

  • Beginners targeting backend or enterprise roles
  • Students whose college syllabus taught outdated Java
  • Anyone heading towards the Spring Boot course

What you need first

  • A computer with at least 8 GB RAM
  • No prior Java experience required

Tools you will use

Java 21 (LTS)IntelliJ IDEA CommunityMavenJUnit 5JacksonGit

By the end you can

  • Write modern Java using records, streams, var, switch expressions and pattern matching
  • Apply object-oriented design without over-engineering
  • Read and write generic code, including the wildcards in library signatures
  • Use collections and the Streams API fluently, and choose between them deliberately
  • Handle exceptions deliberately, read a stack trace, and avoid NullPointerException by design
  • Work with files, dates and JSON — the three things every backend job needs on day one
  • Recognise a race condition, and use executors and virtual threads safely
  • Write unit tests with JUnit 5 and build a project with Maven
  • Finish with a complete command-line application you can show an employer
Reference code

Stuck? Compare your work

The tiffin delivery tracker as the capstone builds it, with its 36 tests. Only module 11 has a checkpoint — the rest of the course is concepts, and publishing disconnected snippets invites copying exactly what the lesson asks you to type.

It is there for when you are stuck, not to start from. Type the code yourself first — copying it will teach you very little.

View on GitHub
Syllabus

13 modules, 76 lessons

Work through these in order. Each lesson is short enough to finish in one sitting and ends with something to build, not a quiz.

  1. 1

    Getting Started

    JDK, IDE, and understanding how Java actually runs.

    1. What Java is and why it is everywhere15 min
    2. JDK, JRE and JVM explained clearly15 min
    3. Installing Java 21 and IntelliJ IDEA20 min
    4. Your first program, and what public static void main means20 min
  2. 2

    Language Basics

    Types, variables, control flow and reading input from a user.

    1. Variables, primitives and var25 min
    2. Strings, text blocks and formatting25 min
    3. Operators and precedence15 min
    4. if, switch expressions and loops30 min
    5. Arrays and their limitations20 min
    6. Reading input from the console20 min
  3. 3

    Object-Oriented Java

    The core of Java, taught with real problems rather than Animal and Dog examples.

    1. Classes, objects and constructors30 min
    2. Encapsulation and access modifiers25 min
    3. Inheritance and polymorphism30 min
    4. Interfaces and default methods30 min
    5. Abstract classes: when and when not20 min
    6. Records: the modern way to hold data25 min
    7. Enums and why they beat constants20 min
    8. Sealed types and pattern matching30 min
  4. 4

    Generics

    The angle brackets in every Java signature you will ever read, explained properly.

    1. Why generics exist, and the raw-type trap25 min
    2. Writing your own generic classes and methods30 min
    3. Wildcards: reading the signatures libraries give you25 min
  5. 5

    Collections

    The part of the standard library you touch every day — and the performance characteristics that turn choosing between them into a decision rather than a habit.

    1. The Collections framework, mapped out20 min
    2. List and ArrayList25 min
    3. Iterating, and removing while you do30 min
    4. Map and HashMap30 min
    5. Set, and removing duplicates properly20 min
    6. Queues, deques and priority queues30 min
    7. equals and hashCode: the contract you must not break30 min
    8. Sorting with Comparator30 min
    9. Immutable collections and defensive copies30 min
    10. What each collection actually costs30 min
    11. Choosing the right collection20 min
  6. 6

    Streams and Functional Java

    The modern way to transform data, and the biggest gap in most college syllabuses.

    1. Lambdas and functional interfaces30 min
    2. Streams: map, filter, collect35 min
    3. Optional, used correctly25 min
    4. Grouping and partitioning with Collectors30 min
    5. Practice: rewriting loops as streams30 min
  7. 7

    Exceptions and Error Handling

    Reading a stack trace, checked versus unchecked, and how to fail usefully.

    1. Exceptions, try, catch and finally25 min
    2. Reading a stack trace, and the debugger25 min
    3. Checked versus unchecked, and the long argument about it25 min
    4. Writing your own exceptions20 min
    5. try-with-resources and closing things properly20 min
    6. null, and designing NullPointerException out25 min
  8. 8

    Files, Dates and Data

    Reading, writing, and the two data types every backend touches: files and timestamps.

    1. Files, Paths and NIO30 min
    2. Reading and writing text and CSV25 min
    3. Dates and times with java.time30 min
    4. JSON with Jackson30 min
  9. 9

    Concurrency

    The module where most candidates come unstuck in interviews, taught by breaking things on purpose and then reading the fix.

    1. Threads, and why a server already has many25 min
    2. Race conditions: breaking a counter on purpose30 min
    3. synchronized, and what a lock actually guarantees35 min
    4. Visibility: the change one thread never sees30 min
    5. Atomics and the concurrent collections35 min
    6. Executors and virtual threads30 min
    7. Futures and CompletableFuture35 min
    8. Deadlock, and finding it in a thread dump30 min
  10. 10

    Build Tools and Testing

    Maven, JUnit and the professional habits that follow you into a job.

    1. Maven: dependencies, lifecycle and the POM30 min
    2. Unit testing with JUnit 535 min
    3. Good assertions and test structure25 min
    4. Structuring a Java project20 min
  11. 11

    Design Patterns in Practice

    The handful a working Java developer actually meets, and the honest warning that most pattern code in the wild is a pattern applied where it was not needed.

    1. What a design pattern really is25 min
    2. Making objects: factory methods and builders35 min
    3. Singleton, and why dependency injection replaced it30 min
    4. Strategy and template method, with lambdas35 min
    5. Adapter, decorator and facade30 min
    6. Observer, listeners and callbacks25 min
    7. Spotting patterns in the JDK — and when not to use one30 min
  12. 12

    Best Practices: Code Others Can Read

    Naming, size, comments and review. The difference between somebody who can make it work and somebody worth hiring.

    1. Naming things, which is most of the job40 min
    2. How big is too big35 min
    3. Comments that say why, and Javadoc that earns its place25 min
    4. Nulls, validation and failing fast30 min
    5. Reading code, and reviewing it without being unbearable30 min
  13. 13

    Capstone: Tiffin Service Tracker

    Everything above, assembled into one command-line application with tests and a runnable jar.

    1. Planning the application before writing it25 min
    2. The domain: records, enums and validation35 min
    3. Storage: CSV, atomic writes and bad rows35 min
    4. The command line, and failing usefully35 min
    5. Tests, coverage of what matters, and packaging a jar30 min
Previous courseKotlin Complete FoundationNext courseJavaScript Complete Foundation

Learning this with a mentor is faster

Going through a course like this one is how you qualify for our six-month internship, for selected students, mostly from Pune. Clear the interview and you build real-world projects with my mentorship.

About the internshipAll courses