A hands-on course

Java, taught the way it is actually written.

Thirty-four sessions that build Java from the ground up, one idea at a time. Every concept comes from first principles, with code you can run and watch unfold, step by step, right on the page. Less reading about Java, more seeing it work.

Start session 1 Open the playground

Your progress0 / 34 sessions

Java foundations

0/7 done

The language itself, from a blank file to arrays. No objects yet, just enough Java to build everything else on.

1Setup, the JVM, and your first programWhat actually happens when Java runs, and writing the first program from an empty file.50 min

2Variables, types, and input/outputStoring values with a fixed type, and the difference between static typing here and Python.55 min

3Operators, expressions, and castingArithmetic, comparison, and logic, plus what integer division and type casting really do.55 min

4Making decisions: if-else and switchBranching, the shape of conditions, and when switch reads better than a chain of ifs.55 min

5Loops: for, while, do-whileRepeating work, the anatomy of a for loop, and how to choose between the three forms.55 min

6Arrays, one dimensionStoring many values under one name, indexing from zero, and walking an array with a loop.60 min

7Arrays, two dimensions, and practiceGrids and tables, nested loops over rows and columns, and the ten one-dimensional problems.60 min

Core object-oriented programming

0/10 done

The heart of the course. What an object is, why it exists, and the four ideas every Java program is built from.

8Why objects? Class vs objectThe problem objects solve, and the difference between a blueprint and the thing built from it.55 min

9Creating classes and objectsWriting your first class with fields, making objects with new, and reading and writing their state.60 min

10Methods: parameters and return valuesGiving objects behavior, passing values in, getting values back, and how arguments are copied.60 min

11ConstructorsBuilding objects in a valid state from the first moment, default vs custom constructors, and overloading them.55 min

12Access modifiers and encapsulationHiding the inside of an object, why private fields plus methods beats exposed data, and getters and setters.55 min

13The this keyword and object referencesWhat this points to, why two variables can share one object, and what equality really compares.55 min

14InheritanceBuilding a new class on top of an existing one, the is-a relationship, and what a subclass inherits.60 min

15Method overriding and superReplacing inherited behavior, calling back up to the parent, and the @Override safety net.55 min

16PolymorphismOne reference type, many runtime shapes, and why a single loop can drive different behavior per object.60 min

17OOP practice: Student, Bank, EmployeePulling every Phase 2 idea together by designing three small, complete classes from scratch.60 min

Advanced object-oriented programming

0/5 done

Abstract classes, interfaces, and the keywords that shape how classes relate and what they promise.

18Abstract classesClasses you cannot instantiate, methods with no body, and forcing subclasses to fill in the blanks.55 min

19InterfacesA pure contract of behavior, implementing one, and why a class can satisfy many at once.55 min

20Interface vs abstract classWhen each one fits, the is-a versus can-do distinction, and how to choose with confidence.50 min

21The static and final keywordsMembers that belong to the class not the object, values that never change, and constants done right.55 min

22Inner classes and OOP consolidationClasses that live inside classes, when nesting helps, and a recap that ties Phases 2 and 3 together.55 min

Java in the real world

0/5 done

Packages, reading from the keyboard, files, and handling the things that go wrong while a program runs.

23Packages and importsOrganizing classes into folders with names, importing what you need, and the classpath.50 min

24Scanner and console applicationsReading numbers and lines from the keyboard, building a small interactive program, and common Scanner traps.55 min

25Reading filesOpening a file, reading it line by line, and why every file operation can fail.55 min

26Writing filesCreating and writing to a file, append versus overwrite, and flushing and closing properly.50 min

27Exception handlingWhat an exception is, try-catch-finally, checked versus unchecked, and throwing your own.60 min

Strings and concurrency

0/4 done

Working with text properly, and a first look at running more than one thing at a time.

28Strings, StringBuilder, StringBufferWhy strings are immutable, the most useful String methods, and when to reach for a builder.60 min

29String practice problemsReversing, counting, checking palindromes, and other classic string exercises solved step by step.60 min

30Introduction to threadsRunning more than one thing at once, the main thread, and creating a thread two ways.55 min

31Thread creation and synchronizationWhy shared data races, what synchronized guarantees, and the lifecycle of a thread.55 min

Modern Java and practice

0/3 done

The features you meet in real codebases, plus a session to read code, debug, and build something end to end.

32Enums, lambdas, and functional interfacesA fixed set of named values, treating behavior as data, and the functional interface that makes it work.60 min

33Annotations, docs, stack traces, and the IDEReading and using annotations, understanding a stack trace, and working effectively in a real editor.55 min

34Practical engineering: build somethingA buffer session to reinforce OOP, troubleshoot, and build one small integrated program end to end.60 min