1Z0-819 — frequently asked questions

Because var infers the full generic type ArrayList<String> for both listA and listC, making the assignment valid.

Then it would be a compile error because ListA is an undeclared identifier, but that is a typo not present in the intended exam code.

The toString() guards the manager reference (typically a ternary), so a null manager is rendered as the literal text "None" instead of being dereferenced.

The same toString() also appends the reports collection's size, and AA was created with two reports (BB and CC), so "Reports: 2" must appear in the line.

Java does not allow combining type-inferred parameters (var) with explicitly typed parameters in the same lambda expression to maintain clarity and consistency.

Yes, you can apply final to individual parameters, but it is often unnecessary for var-inferred parameters and can lead to confusion if not applied consistently.

The PreparedStatement is prepared once and then reused with new setInt/setString parameters before each executeUpdate, so only two objects exist even though it is executed more than once.

No resource is abandoned: JDBC releases a Connection's Statements and ResultSets when the Connection is closed, which the shown code does, so no leak occurs.

findAny() and findFirst() return Optional<Item>, not a boolean, so they cannot be used directly as an if condition; you would need to append isPresent().

allMatch returns true only if every item satisfies the predicate, so it answers a different question and is wrong when you just need to detect one item with count below zero.

The loop condition is tested before each pass; once the counter is no longer less than 10 the body is skipped, so 11 is never printed.

It lists the correct odd values but ignores the terminating bound, adding one iteration the loop never executes — a classic off-by-one trap.

JLS 15.27.1 makes var in lambda parameters all-or-nothing: if any parameter uses var, every parameter must use var. Mixing var with Integer is a compile-time error, so option A fails.

Yes. Any lambda parameter list that uses var, or that is implicitly typed with more than one parameter, must be enclosed in parentheses, which is why option C's bare var x, var y -> form is a syntax error.

Generic types are invariant: House<Animal> is not a subtype of House<Dog>, so the return fails to compile. Supertype substitution only works when the declared type is the wildcard House<? super Dog>.

Yes. A raw constructor call is assignable to House<Dog> with just an unchecked-conversion warning, which is why the raw/diamond form is counted as one of the two correct answers.

Console.readPassword suppresses echo while Java is typed, so the password appears only later when String.valueOf(password) is printed.

Direct concatenation or println's Object handling would produce a hash code like [C@... instead of Java; String.valueOf(char[]) prevents that.

List.of returns an immutable list, and List.sort() must replace elements in place; since the list cannot be modified, the JDK throws UnsupportedOperationException at runtime.

Option A, [Red:75, Red:100, Yellow:50, Yellow:75], because a mutable list can actually be sorted by hue and then by value.

The compiler only knows values is A[]. Since C extends A, the assignment is legal at compile time. Runtime checks enforce the actual array type.

Change the instantiation to new A[2] so the array can hold any subtype of A, including both B and C.

Yes, if it is the only element in the annotation.

No, you must use the exact name 'value' as defined in the interface.

In JDK 9+, variables only need to be effectively final (not reassigned) rather than explicitly declared with the final keyword to be used in try-with-resources.

JDK 9 extended the scope of resources to include effectively final variables defined outside the try statement, whereas JDK 7/8 required declaration inside the parentheses.

While Throwable is the superclass, extending it directly is too broad. RuntimeException is the standard parent for unchecked exceptions that terminate programs naturally.

No, extending Exception creates a checked exception. The compiler forces you to handle it, so it won't necessarily terminate the program if caught.

Final requires explicit declaration; effectively final means the compiler infers it because the value is never reassigned.

Yes. Effectively final restricts reassignment of the reference, not modification of the object's internal state.

It sends both via PropertyChangeEvent. However, if the listener reads the bean's field directly, it gets the new value if the field was updated first.

Because it uses PropertyChangeSupport to notify listeners of changes, allowing other components to react dynamically to state updates.