Java SE 8 Programmer I (OCAJP 8) study plan

Compile and run Java source files from the command line using javac and java, explaining the role of the classpath and package directory layout.

Declare classes, instance variables, static variables, and local variables, then predict each variable's default value or compile error before testing it.

Write a main method in several legal and illegal signature variants and state why each one is or is not a valid entry point.

Convert between primitive types and wrapper classes, distinguishing widening from narrowing and identifying which conversions need an explicit cast.

Build a small program that uses String, StringBuilder, and primitive wrappers together, and annotate each line with the type rules it exercises.

Evaluate expressions involving operator precedence, associativity, short-circuit && and ||, and compound assignment, writing the result before executing the code.

Distinguish pre-increment from post-increment inside larger expressions and explain the resulting values step by step.

Rewrite if/else chains as switch statements and identify which argument types and case labels are legal in Java 8.

Convert between while, do-while, and for loops, and choose a loop form that guarantees at least one iteration when required.

Trace nested loops with break and labeled continue on paper, predicting the exact iteration count and final variable values.

Declare, instantiate, and initialize one-dimensional and two-dimensional arrays using both literal and new-based syntax, including ragged arrays.

Explain the difference between an array reference, an array object, and ArrayIndexOutOfBoundsException, and demonstrate each in code.

Iterate arrays with both a classic for loop and an enhanced for loop, and state when the enhanced form cannot be used.

Use Arrays.sort, Arrays.toString, and System.arraycopy correctly, and describe what each does to the array argument.

Combine arrays with loops to compute aggregates, reverse contents in place, and search for a value without using library search methods.

Write overloaded methods and predict which overload the compiler selects for a given call, including widening versus boxing versus varargs.

Apply the four access modifiers to fields, methods, and constructors, and state which callers in which packages can reach each member.

Implement encapsulation for a class by making fields private and exposing validated getters and setters, including a boolean getter naming convention.

Use static members, static methods, and static initialization blocks, and explain why a static method cannot use the this keyword.

Create constructors that chain with this(...) and explain constructor overloading versus method overloading.

Design a three-level class hierarchy and override methods, verifying polymorphic dispatch through a superclass reference.

Distinguish overriding from overloading and list the rules an override must satisfy regarding return type, access, and checked exceptions.

Use super to call parent constructors and methods, and explain constructor execution order in a hierarchy.

Declare abstract classes and interfaces, implement multiple interfaces in one class, and resolve a default-method conflict by overriding it.

Apply casting and instanceof to safely downcast a reference, and demonstrate the ClassCastException that occurs without a check.

Classify exceptions as checked, unchecked, or errors, and state which ones the compiler forces you to handle or declare.

Write try-catch-finally blocks and predict the exact output when a catch block returns or throws and a finally block also returns.

Use try-with-resources with AutoCloseable resources and explain the order in which close methods run relative to catch and finally.

Create a custom checked exception and a custom runtime exception, and declare the checked one with throws on the calling method.

Explain how exception propagation unwinds the call stack and identify which method in a chain is allowed to catch a given exception.

Manipulate strings with charAt, length, substring, indexOf, replace, trim, and equals, distinguishing equals from == on string literals and new String objects.

Format and parse dates with LocalDate, LocalDateTime, and DateTimeFormatter, and explain immutability when plusDays or minusMonths is called.

Use ArrayList and its add, remove, get, size, and contains methods, and predict the effect of removing by index versus by object.

Build and traverse a simple HashMap, explaining what happens when a duplicate key is put and how to iterate entries safely.

Differentiate StringBuilder mutation from String immutability with a loop that concatenates inside versus outside a builder.

Re-run every earlier deliverable from a clean directory and fix anything that no longer compiles or behaves as documented.

Take two full-length timed practice tests and log every wrong answer by domain and by root cause (syntax, semantics, or misreading).

Re-study only the two weakest domains from that log, rewriting your cheat sheets for those domains from memory.

Recite the ten most common trap patterns (integer division, missing braces, finally overriding return, array length versus String length, and similar) without notes.

Simulate exam conditions once more under a strict time limit and confirm a score above your target threshold.