Thirty guides for a first-year Java sequence, in the order the course teaches the material. Part 1 runs from what a program is made of to loops and Strings. Part 2 covers inheritance and polymorphism, arrays and generics, exceptions, files and recursion.
Start at the top if you are working through the course, or jump to the idea that is costing you marks. Part 1 covers everything up to a typical first exam.
Retrieve instead of reread, space the sessions, read every explanation, and trace code by hand — with a two-week plan. Works without a class.
Every beginner Java term, from identifier and literal to instance, parameter and static, pointed at in one parking-garage ticket program that grows section by section.
The six steps from a problem to a working program, walked through one laundromat pricing program: statement, decomposition, class and method design, coding, then testing and revising.
What every word of Hello World is doing — and the exact error each one gives when you change it.
javac makes bytecode, java runs it. Two tools, two kinds of error, and the five you hit first.
Take int bikesAvailable = 12; apart word by word at a bike rental shop: legal names, keywords, literals, final constants and the real compiler errors behind each rule.
All eight types, plus integer division, silent overflow, floating-point drift and char arithmetic.
The plus sign is two different operators. That is where the wrong output comes from.
A campsite booking desk asks for nights, people and a name: nextInt versus nextLine, the empty-line trap and its fixes, and one Scanner per program.
Prefix versus postfix in plain English — why x = x++ does nothing, and the hidden cast inside every compound assignment.
A draft that looks finished, fails to compile, then compiles and is still wrong.
Four methods can share one name, and the compiler picks without ever looking at what they return. Plus what static really means, and the two words everyone swaps.
Where a Java variable can be used and how long it lives, shown with a growing vending machine class: block scope, stack frames, the heap and references.
@param, @return and the comment that becomes a web pageRename and document a coffee-shop LoyaltyCard class step by step: camelCase, PascalCase and constants, /** */ versus /* */, @param, @return, and a real javadoc run.
Test cases that sit on the edge of the rule, the assert that does nothing until you ask, and the classes that box an int.
Integer division, promotion, casts that chop instead of round, the Math class, and the three-step recipe for rounding to two places.
AND, OR and NOT, the right-hand side Java never looks at, the dangling else, and the switch that keeps going without break.
Three ways to say “again”, counting a nested loop's passes on paper, what break and continue skip, and the semicolon that empties a loop.
Indexes from zero, the substring end that is never included, the comparison that checks the wrong thing, and the one String type you can change.
The second half of the course, in teaching order: inheritance, the Object class, polymorphism, abstract classes and interfaces, then arrays, 2D arrays, ArrayLists and generics, then exceptions, files and recursion. Each guide ends with practice questions, worked solutions and a test-readiness checklist.
The recipe card you copy and change: extends, the super(...) call every child constructor makes, and overriding versus overloading.
Why your object prints as Pet@1b6d3586, why two identical points are not equal, and the parameter type that breaks a hand-written equals.
One call, the right method: what the variable lets you call, what the object decides to run, casting safely, and the is-a versus has-a test.
The half-finished parent class and the promise any class can make: abstract methods, implements, Comparable, and when to choose which.
The egg carton with numbered cups: new, length, why passing an array lets a method change it, and adding, finding and removing in an oversized array.
Row first, then column: the two different lengths, row-major and column-major loops, row and column totals, ragged rows and three dimensions.
The array that grows: add, get, set, remove, the remove call that deletes the wrong item, size versus capacity, and Vector.
The box with a blank label: generic methods, <T extends Comparable<T>>, generic classes like Pair<A, B>, and what generics cannot do.
The smoke alarm, not the cook watching every pan: reading a stack trace, catch order, finally, the block-count rules, and checked versus unchecked.
Open, use, close: PrintWriter, Scanner versus BufferedReader, the file that stayed empty, and the Scanner that read the file name.
Nesting dolls and the base case: the four questions, watching the stack unwind, and factorial, GCD, Fibonacci, binary search and the Towers of Hanoi.
Reading an explanation is not the same as producing the answer under time pressure. The free Java practice app draws from 1,060 written questions, every one with a worked explanation, and you can pick the topic you just read about. The questions cover both parts: every Part 2 topic has 40 questions, and each Part 2 guide also carries its own practice set with worked solutions. It runs offline, keeps your progress on your own device, and asks for nothing.
Want the overview first? The Java practice test page lists every topic the app covers.
Topic-selectable practice with worked explanations. Offline, no ads, no account.
Start practising →Looking for a different class? Python · Discrete Math · Networking · Security+ · Calculus, or the full guide catalog.