Java Essentials

print vs println, joining text with +, writing comments, and printing special characters.

The compile-run cycle, the anatomy of an error message, and the five errors every Java beginner meets in week one.

Declare, initialize, and reassign variables — and learn Java's naming rules.

int, double, boolean, and char — Java's four essential primitives, and why the compiler cares.

Arithmetic operators, why 7 / 2 is 3, the remainder operator %, and the shortcuts += and ++.

Widening happens automatically; narrowing needs a cast — and casting is how you fix integer division.

Create strings, measure them, grab characters and pieces — and meet the .equals() rule early.

Make programs interactive: import Scanner, read numbers and text, and dodge the infamous nextInt/nextLine trap.

The six comparison operators, boolean expressions, and the string-comparison rule that saves exams.

Branch your program: if statements, else-if chains, nesting, and why order matters.

Combine conditions with AND, OR, and NOT — plus short-circuiting and the range-check idiom.

Clean multi-way branching with switch (and its fall-through trap), plus the one-line if: ?: .

Put Module 3 together: trace realistic programs by hand, exactly the way written exams demand.

Repeat code while a condition holds — counters, updates, and how loops end (or don't).

The counting loop: init, condition, update in one line — plus counting down, stepping, and scope.

The run-first loop for menus and validation, and the two keywords that redirect any loop.

Loops inside loops: times tables, star triangles, and how to count total iterations.

The five loop patterns every exam tests: accumulate, count, min/max, search, and digit-processing.

Name a block of code once, run it anywhere: defining and calling static methods.

Give methods input: parameters vs arguments, multiple inputs, pass-by-value, and where variables live.

Methods that hand back results: return types, using returned values, early returns, and boolean predicates.

Same name, different parameters — plus the Math methods every course uses: pow, sqrt, abs, max, round, random.

Decomposition: turning a problem into small methods, and answering the 'write a method that…' exam question.

One variable, many values: creating arrays, indexing from zero, .length, and the out-of-bounds crash.

The index loop and the for-each loop — and the crucial rule about which one can modify elements.

Sum & average, min/max with index, linear search, counting, and reversal — the five array questions every exam asks.

Grids: rows and columns, nested traversal, and the length rules that exams test.

Loop through strings char by char, build new strings, count and filter — plus StringBuilder for heavy lifting.

Pass arrays to methods, return arrays from methods — and learn why a method CAN modify your array.

The idea that organizes all modern Java: classes as blueprints, objects as instances, state plus behavior.

Design and build a complete class from a spec: fields, methods that use them, and objects working together.

Build objects ready-to-use: constructor syntax, the this keyword, overloaded constructors, and the default-constructor rule.

Protect your objects' state: private fields, public getters/setters, and validation at the gate.

One per class or one per object? static fields, static methods, constants, and why main is static.

Objects behave like arrays: references, aliasing, null and the NullPointerException, plus writing equals and toString.

Build new classes on top of existing ones: extends, is-a relationships, and what gets inherited.

Chain constructors up the hierarchy with super(), and replace inherited behavior by overriding.

One variable type, many behaviors: superclass references, dynamic dispatch, casting, and instanceof.

Classes that exist only to be extended: abstract methods, why you can't instantiate, and the template pattern.

Pure contracts: implements, multiple interfaces, interface vs abstract class, and Comparable.

The hierarchy-trace drill, design-from-spec, and every OOP trap from Modules 7–8 in one battle-tested checklist.

The growable list: add, get, set, remove, size — plus generics syntax and wrapper types.

The Module-6 algorithms on ArrayLists, building filtered lists, and the infamous remove-while-iterating bug.

Key → value lookup: put, get, containsKey, getOrDefault, looping with keySet — and the frequency-count exam classic.

The uniqueness collection, the dedupe pattern, and the list/set/map decision guide.

Crash-proof your programs: how exceptions propagate, try/catch/finally, and catching multiple types.

Throw your own exceptions, understand checked vs unchecked and throws, and build the bulletproof input loop.

Methods that call themselves: base case, recursive case, the call stack, and tracing factorial by hand.

Fibonacci, sum of digits, power, string reversal — the four recursions exams actually set, plus recursion vs loops.

Binary search's halving magic, selection sort pass by pass — and how to answer 'how many comparisons?'

Persist data: Scanner over a File, the hasNextLine loop, PrintWriter output, and why close() matters.

Build a complete system — encapsulated class, ArrayList registry, menu loop, search, statistics — the way exams compose everything.

How to take a Java exam: the four question types, the tracing protocol, the trap master-list, and your revision map.