Explore wrapper classes for primitive types like int, double, and char, and learn parse methods and valueOf, including boxing, unboxing, and hex base parsing.

Explore unary and binary operators, including prefix and postfix increments, casting, and string concatenation, and master operator precedence from prefix to assignment.

Explore relational and logical operators in Java 8, including ==, !=, >, <, >=, <=, boolean short-circuit with && and ||, and non-short-circuit bitwise operators for booleans and integers.

Explore the ternary operator in Java, evaluating boolean expressions to decide which value to assign, including nested ternaries, and master compound assignment with implicit casts and precedence rules.

Explore how strings in Java are objects, immutable, and stored in the string pool, with examples of construction, concatenation, equals versus the double equals operator.

Explore how Java handles string equality, comparing references with == vs content with the equals method, and how string literals reside in the string pool while new strings differ.

Demonstrate string chaining in Java by concatenating, uppercasing, and replacing on a string, and explore immutable objects, string literals in the constant pool, and memory plus garbage collection.

Explore essential string api methods in Java 8 OCA fundamentals, including charAt, concat, equalsIgnoreCase, length, replace, substring, toLowerCase, toUpperCase, and trim, with practical examples and usage.

Compare immutable strings with mutable string builder to perform in-place modifications using append, reverse, and insert. Highlight string builder’s efficiency for large data blocks and threading considerations with string buffer.

Master string manipulation with the StringBuilder API, learning append, delete, insert, reverse, and toString, alongside length, capacity, and error handling for invalid indices.

Explain UML, the unified modeling language, via a simple circle class; show public, private, and static class variables and use a scanner for input to calculate diameter, radius, and area.

explore implementing user input handling and method-driven calculations: pass a radius to a diameter method, calculate and return the diameter and area, and output the results in main.

Learn to implement circle calculations in Java by using static methods for diameter, circumference, and area, reading radius with a scanner and leveraging Math.PI.

Learn how if statements control program flow by evaluating boolean expressions and branching to if, else if, or else blocks or single statements. Understand indentation and the dangling else rule.

Master switch statements as a concise alternative to nested if-else, using compile-time constant case labels, default handling, and breaks to prevent fall-through, including strings.

Explore Java iteration with while and do-while loops, their syntax and evaluation order, and the distinction between zero-or-more and one-or-more execution, plus semicolon requirements.

Master Java iteration with both basic and enhanced for loops, understanding for loop syntax: initialization, condition, update, and scope rules to avoid infinite loops and scope errors.

Explore the enhanced for loop for iterating arrays and collections that implement iterable, with clear syntax and block scope. Learn common pitfalls like name conflicts and non-iterables.

Explore break and continue statements in Java 8 across nested loops, including two-dimensional arrays and labeled breaks, to control loop flow and skip iterations with clarity.

Learn to create methods with arguments and return values, including overloaded versions, and understand method signatures, parameter types, return types, and calling static methods.

Apply the static keyword to share class variables and utility methods, accessed via the class name rather than an object, with a static count tracking object creation across all instances.

Discover how constructors create objects in Java, including overloading, the default constructor provided by the compiler, and calling super in inheritance. See examples with dog, cat, and mouse.

Explore Java access modifiers and encapsulation, showing private data hidden behind public accessors. Compare package-private, protected, and public scopes with constructors, validation, and getters to protect state.

Java passes arguments by value, copying primitives and references. A called method can alter a referenced object, but not the primitive, shown when John becomes Michael and age stays 20.

Explore Java's object oriented concepts: scope, classes, encapsulation, and overloading, and examine the this reference and object lifecycle from creation to garbage collection.

Demonstrate encapsulation and scope in Java by modeling a person with private fields, a static count, constructor overloading, and this reference, plus getters, setters, and garbage collection notes.

Explore memory behavior with object references and a class variable count, showing how setting a name, getting count, scope errors, and garbage collection occur.

Explore how the JVM loads a class, initializes static members, allocates heap objects, initializes instances, and executes constructors in SAIC order.

Create immutable types by using final classes and final fields, avoid setters, and employ defensive copying for mutable fields, illustrated by a final person example and call-by-value concepts.

Explore how to enforce immutability in a department class using private constructors, final fields, and defensive copying via a public static method that creates a new instance to prevent mutation.

Compare strings and string builders, proving strings are immutable and string builders mutable; show overloading, by-value passing, and how append affects builders but not strings.

Explore inheritance and polymorphism by examining subtypes and superclasses, overriding and overloading, and how object type and reference type drive runtime behavior in Java.

Explore inheritance, polymorphism, and the nuances of overriding and overloading in Java, including how reference types guide method resolution, runtime dispatch, and covariant returns.

Demonstrate how the instanceof keyword and the equals method govern object comparison, with safe downcasting and the hashCode contract for equal objects in collections.

Master the super keyword in constructors and methods within an inheritance chain—employee, manager, director—ensuring the first line calls the parent constructor and overriding toString.

Explore how the protected modifier blends package visibility with inheritance, letting a subclass access members across packages while keeping them private to external code.

Master how constructors initialize objects, require the class name, and have no return type; learn about default no-arg constructors and how super and this calls control inheritance initialization.

Explore how abstract methods have no implementation and force subclass overrides, why abstract classes cannot be instantiated or marked final, and how casting works with abstract references.

Explore upcasting and downcasting in an inheritance hierarchy with animal and dog, showing implicit upcasts, polymorphic method calls, and instanceof checks to avoid a class cast exception.

Explore interfaces as contracts that define what a class can do, using implements, constants, and default or static methods, while respecting access and inheritance rules for multiple interface use.

Learn how Java 8 default and static interface methods preserve backward compatibility by adding concrete implementations in interfaces, and distinguish instance default methods from static interface methods with examples.

Learn how Java handles multiple interface inheritance with default methods to prevent the diamond of death, and how to access interface methods using super in a class implementing multiple interfaces.

Identify functional interfaces by a single abstract method (sam rule) and note that default, static, and Object methods do not count. Use the @FunctionalInterface annotation to validate and distinguish cases.

Master enumerations in Java by using type-safe, finite value sets like north, south, east and west, with compile-time checks, ordinal and name, and the values method for iteration.

Master complex enums in Java by using private final fields and constructors, plus constant-specific class bodies to override methods. Observe one-time initialization and weekday office vs weekend home behavior.

Explore the object life-cycle from creation with the new keyword to garbage collection. Learn how stack and heap storage interact, and how references determine memory reclamation.

Explore how static variables initialize before constructors and how instance variables initialize per object, and how this constructor chaining and super/this calls affect access to fields during object creation.

Explore Java exception handling with try-catch-finally and try-with-resources, distinguish checked versus unchecked exceptions, and trace how the call stack propagates errors (e.g., null pointer, array index out of bounds).

Master exception handling in java by using try-catch blocks to manage runtime and checked exceptions, catch the most specific first with braces and unique identifiers, and enforce proper throws.

Master the finally block, which always executes to close resources such as files and database connections, regardless of exceptions; learn the correct try-catch-finally ordering and behavior.

Explore the try-with-resources statement, where resources implementing auto closeable are closed automatically in reverse order by an implicit finally, with optional catch and explicit finally.

Master try-with-resources to automatically close resources in reverse order, observe suppressed exceptions from implicit finally and catch blocks, and determine the main vs suppressed exceptions.

Override methods cannot add new checked exceptions in the signature; the compiler enforces the base method's throws clause via the reference type, while runtime binding respects the subclass.

Create custom exceptions by extending the API exception, adding constructors for no-arg, string, and wrapped exceptions, and wrap or hide underlying exceptions when signaling errors to clients.

Explore how to declare, instantiate, and initialize arrays in Java, including one- and multi-dimensional arrays of primitives and object references, with attention to memory layout and zero-based indexing.

Understand how Java initializes arrays, including arrays of objects as references, indexing and length work, and how jagged and multidimensional arrays are represented in memory.

Use anonymous arrays and the just-in-time array shortcut to create and pass an array directly to a method, with size inferred from the number of elements.

Explore how primitive and object arrays handle promotion and is-a assignments, including interface and subclass compatibility, through examples with car, Subaru, Ferrari, and 2D arrays.

Explore a sample two-dimensional array question by running a class with an overloaded main, passing a string array as runtime arguments, and tracing a two-dimensional array of arrays.

Examine how many objects are created when using arrays of X and integer wrappers, and how caching integer wrappers impacts memory and garbage collection, with a test proving cache reuse.

Explore arraylists in java 8, comparing them with arrays, and learn how generics, wrapper types, and overridden equals and toString shape storage, indexing, and removal in arraylists.

Explore Java 8 lambdas and learn how functional interfaces and the single abstract method rule enable concise, anonymous implementations for predicate expressions.

Demonstrate using a custom functional interface for evaluation with generics and a single abstract method, then implement a lambda for is negative returning boolean, and compare to the API predicate.

Learn how the Predicate functional interface works with lambdas, using a generic check method to test integers then strings via the test method, with examples like starts with 'Mr.'.

Explore calendar data using the java.time library, including local dates and times, date-time formatter, and period, with emphasis on immutable classes and factory methods like now and parse.

Explore creating local date and time instances in Java 8 using of(), now(), and parse(), and observe outputs for LocalDate, LocalTime, and LocalDateTime.

Explore formatting dates and times in Java 8 using format strings, including M vs m, symbol counts, and LocalDate, LocalTime, LocalDateTime, TemporalAccessor compatibility with predefined iso formats.

Learn how period objects represent years, months, weeks, and days, created via static factories; study immutability, adding days with plusDays, and that weeks are stored as days.