Java SE 8 Programmer I (OCAJP 8) key terms

One of Java's eight built-in non-object types (boolean, byte, short, int, long, char, float, double) that stores a raw value directly, is never null, and cannot have methods called on it.

An object type such as Integer, Double, Character, or Boolean that boxes a primitive value so it can be stored in collections, be null, and be used where an object is required.

The compiler's automatic conversion of a primitive to its matching wrapper type, and the reverse unboxing, when an assignment or method call requires the other form.

Automatic widening of operands in an expression to a common type (for example byte and int become int) before the operation is performed, which can change the result's type.

An explicit type conversion written in parentheses, needed to narrow a wider primitive into a smaller one or to treat a reference as a more specific type, with possible truncation or runtime failure.

A variable declared inside a method, constructor, or block. It has no default value, must be assigned before use, and lives only while that block executes.

A non-static field declared in a class body. Each object gets its own copy, and it receives a default value (0, false, or null) if not explicitly initialized.

A field declared with the static modifier. Exactly one copy exists per class, it is shared by all instances, and it is initialized when the class is first loaded.

The value Java assigns automatically to fields that are not initialized: zero for numeric primitives, false for boolean, '\u0000' for char, and null for object references. Local variables get none.

The region of a program where a declared name can be referenced. It typically extends from the declaration to the end of the enclosing block, and inner blocks may shadow outer names.

Declaring a variable or parameter whose name matches one in an enclosing scope or a field, so the inner declaration hides the outer one inside its own scope.

A reference inside an instance method or constructor that points to the current object, used to reach hidden fields, call another constructor, or pass the object itself.

A special member with the class name and no return type that initializes a new object. If no constructor is declared, the compiler supplies a no-argument one.

The no-argument constructor the compiler inserts only when a class declares no constructor at all; it takes no parameters and simply calls the superclass no-argument constructor.

Hiding a class's internal fields behind private access and exposing controlled behavior through public methods, so callers cannot corrupt state and implementation can change freely.

A keyword (private, package-private by default, protected, or public) that controls which other classes may see a class, field, method, or constructor.

An access level allowing access from the same package and from subclasses in any package, but only through inheritance or a reference of the subclass type.

The mechanism where a class extends another and reuses its accessible fields and methods, forming an is-a relationship; Java permits a single superclass but multiple interface implementation.

A reference used inside a subclass to call the superclass constructor, invoke an overridden superclass method, or reach a hidden superclass field.

Redefining an inherited instance method in a subclass with the same signature. The subclass version is chosen at runtime, and the return type may be covariant.

Declaring several methods with the same name but different parameter lists in one class. The compiler selects one at compile time based on argument types.

The ability of a superclass or interface reference to refer to objects of different subtypes, with the actual overridden method chosen at runtime.

A class declared abstract that cannot be instantiated and may declare abstract methods without bodies, which concrete subclasses must implement.

A contract declaring abstract methods (and, since Java 8, default and static methods) that implementing classes must fulfill; a class may implement many interfaces.

A method in an interface declared with the default keyword that supplies a body, so implementing classes inherit it without being forced to override it.

A runtime exception thrown when an explicit downcast to a type the object is not actually an instance of is executed.

A boolean operator that tests whether a reference is non-null and refers to an object compatible with a given type, often used to guard a downcast.

An exception that is not a RuntimeException or Error and that the compiler requires to be caught or declared with throws in the method signature.

A RuntimeException or Error subclass that the compiler does not force you to catch or declare, such as NullPointerException or IllegalArgumentException.

The construct that runs guarded code in try, handles matching exceptions in catch blocks, and always runs finally, even when an exception escapes or a return occurs.

A try statement declaring one or more AutoCloseable resources in parentheses, which are closed automatically in reverse order when the block finishes.

A runtime exception thrown when code invokes a method or accesses a field through a reference that holds null.

A multi-branch construct comparing an expression against case labels of int-compatible types, enums, or String; execution falls through unless break or return is used.

The only three-operand operator, written condition ? valueIfTrue : valueIfFalse, which evaluates to one of two values based on a boolean test.

Behavior of && and || where the right operand is skipped when the left already determines the result; single & and | always evaluate both sides.

A statement that exits the nearest enclosing loop or switch immediately; with an optional label it exits the labeled outer statement.

A statement that skips the rest of the current loop iteration and proceeds to the next one, honoring any label to target an outer loop.

A loop with initialization, boolean condition, and update sections, or the enhanced form that iterates over arrays and Iterable collections.

A loop that tests a boolean condition before each iteration and repeats its body while the condition remains true, executing zero or more times.

A loop that runs its body first and then tests the condition, so the body always executes at least once.

A fixed-length container of same-typed values created with new or an initializer, indexed from zero, whose length is exposed as a final field.

An array whose elements are themselves arrays, such as int[][], which need not be rectangular because each nested array can have a different length.

The runtime exception (ArrayIndexOutOfBoundsException) thrown when an array is accessed with an index below zero or at least its length.

The property that a String's character content never changes after creation; methods like trim or replace return a new String instead of modifying the original.

A mutable sequence of characters offering append, insert, and reverse operations that change the same object, commonly used to build strings efficiently.

A cache of string literals in memory; identical literals share one object, while strings made with new String always create a distinct object.

The method used to compare logical content. Object's version compares references, so classes like String and wrapper types override it to compare values.

A resizable-array implementation of List that grows automatically, supports index access, and stores objects rather than primitives.

A java.time type such as LocalDate or LocalDateTime whose 'with' and 'plus' methods return a new instance instead of changing the original.

The entry point with the exact signature public static void main(String[] args), which the JVM invokes to start a standalone application.

A method declared with static that belongs to the class, not an object, so it is called through the class name and cannot use this or instance fields directly.

A parameter written with three dots, such as String... names, that accepts zero or more arguments and is received inside the method as an array.

A public method, conventionally named getX or isX, that returns the value of a private field, often the read half of an encapsulated property.

The optional first statement naming a class's package, which must precede imports and determines the class's fully qualified name and default package-private access.

A declaration that lets code use simple names from another package; a single-type import names one class, while a wildcard import covers a whole package but not its subpackages.