Oracle Java Foundations 1Z0-811 (1Z0-811) — Questions 376–450

Why this answer

How to eliminate wrong answers

Option B is wrong because 20 would result from an incorrect operation like subtracting 2 instead of adding, or misreading the operands. Option C is wrong because 21 would come from a miscalculation such as 10 + 11 or a off-by-one error. Option D is wrong because 23 would require an extra increment or addition of 1 beyond the correct sum.

Why this answer

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because SQLException is not a subclass of IOException; it is a completely unrelated checked exception, and throwing it would violate the rule that an overriding method cannot throw a new or broader checked exception. Option C is wrong because Exception is a superclass of IOException, making it a broader checked exception, which is not allowed in an overriding method. Option D is wrong because Throwable is the root of the entire exception hierarchy and is broader than IOException, so it is not permitted.

Why this answer

Why this answer

Why this answer

Why this answer

Why this answer

Why this answer

Why this answer

Why this answer

How to eliminate wrong answers

Option B is wrong because String.concat() creates a new String object for each concatenation, which is inefficient in a loop due to repeated object allocation and copying. Option C is wrong because the '+' operator compiles to StringBuilder.append() only when used in a single expression; inside a loop, each iteration creates a new StringBuilder, resulting in the same performance penalty as explicit String concatenation. Option D is wrong because StringBuffer is thread-safe with synchronized methods, which adds unnecessary overhead in a single-threaded context, making it slower than StringBuilder.

Why this answer

How to eliminate wrong answers

Option A is wrong because the code compiles without error; both s1 and s2 are valid String objects. Option C is wrong because == compares references, not values; s1 and s2 are different objects even though they contain the same characters. Option D is wrong because no runtime exception occurs; the comparison simply evaluates to false and the else branch executes normally.

Why this answer

Why these pairings

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because the multi-catch syntax `catch (IOException | NumberFormatException e)` is valid in Java 7+; it correctly catches both exception types. Option C is wrong because there is a compilation error due to the illegal assignment to `e`. Option D is wrong because the `throw e;` statement is commented out, so it does not cause an error; even if uncommented, the error would still be the assignment, not the throw.

Why this answer

How to eliminate wrong answers

Option A is wrong because although `arr[0]` would be assigned 0 if the loop completed, the exception halts execution before the print statement. Option B is wrong because `arr.length` is 5, but the loop never assigns 5 to any element; the exception prevents any output. Option C is wrong because 4 is the last valid index, but the loop attempts to access index 5, causing an exception.

Why this answer

How to eliminate wrong answers

Option A is wrong because it suggests the result is 3.0, which would only occur if the division were 5 / 1.666... or if rounding occurred, but Java integer division truncates toward zero, not rounds. Option B is wrong because it outputs 2 (an int), but the variable z is declared as double, so the printed value will have a decimal point, i.e., 2.0, not 2. Option D is wrong because it assumes floating-point division occurs, but since both operands are int, integer division is performed first, yielding 2, not 2.5.

Why this answer

How to eliminate wrong answers

Option A is wrong because the code compiles successfully; `concat()` is a valid method on String objects. Option B is wrong because it assumes `concat()` modifies the original string, but strings are immutable in Java. Option D is wrong for the same reason as B — it incorrectly expects the concatenated result to be printed.

Why this answer

How to eliminate wrong answers

Option A is wrong because closing resources in a finally block without null checks can cause a `NullPointerException` if the resource variable is null, and it still requires verbose boilerplate code. Option B is wrong because garbage collection only reclaims memory, not external resources like file handles or database connections; relying on it can lead to resource exhaustion. Option D is wrong because closing resources in a catch block only executes if an exception occurs, leaving resources open if the try block completes normally, which defeats the purpose of guaranteed cleanup.

Why this answer

How to eliminate wrong answers

Why this answer

How to eliminate wrong answers

Option A is wrong because `com.example.*` is not a valid package name for the `javadoc` command; it would be interpreted as a literal package name with an asterisk, causing the tool to fail to find any classes. Option B is wrong because it uses `-private` which includes private members, but the requirement is to include only public and protected classes and methods, and it omits the `-header` and `-footer` options. Option D is wrong because `-subpackages com.example` recursively includes all subpackages (e.g., `com.example.internal`), which may include packages not intended for documentation, and it does not restrict to the three specified packages.

Why this answer

How to eliminate wrong answers

Option A is wrong because it assumes the method modifies the original array, but the assignment `data = new int[]{10,20}` only changes the local reference, not the caller's array. Option B is wrong because the code compiles successfully; the method signature matches the call, and no syntax or type errors exist. Option D is wrong because it suggests the array element becomes 0, which would only happen if the original array were modified to contain 0, but no such modification occurs.

Why this answer

How to eliminate wrong answers

Option B is wrong because the array is initialized with `{5}` and never modified in the calling scope, so `arr[0]` is 5, not 0. Option C is wrong because there is no compilation error; Java allows reassigning a method parameter (the local reference) to a new array, as the parameter is a local variable. Option D is wrong because the new array `{100}` is only assigned to the local reference inside `modifyArray` and does not affect the original array in `main`, so `arr[0]` remains 5, not 100.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because `jar` is used to create, view, or extract Java Archive (JAR) files, not to run applications. Option B is wrong because `javac` is the Java compiler that translates `.java` source files into `.class` bytecode, but it does not execute them. Option D is wrong because `javadoc` generates API documentation from Java source code comments, not run applications.

Why this answer

How to eliminate wrong answers

Option A is wrong because a while loop evaluates its condition before the first iteration; if the list is empty, the condition (e.g., while(index < list.size())) is false initially, so the loop body never executes. Option B is wrong because an enhanced for loop iterates over elements of a collection or array; if the list is empty, there are no elements to iterate over, so the loop body never runs. Option D is wrong because a for loop (traditional) evaluates its condition before each iteration; if the list is empty, the condition (e.g., for(int i=0; i<list.size(); i++)) is false initially, so the loop body never executes.

Why this answer

How to eliminate wrong answers

Option A is wrong because 10 would be the result if the loop only summed the first four elements (1+2+3+4) and then subtracted 0, or if a different arithmetic error occurred. Option B is wrong because 13 would be the result if the sum was 16 and then 3 was subtracted, or if the loop incorrectly skipped an element or added an extra value. Option D is wrong because 11 would be the result if the sum was 14 (e.g., missing one element like 5) and then 3 was subtracted, or if the subtraction was misapplied.

Why this answer

How to eliminate wrong answers

Option A is wrong because `private` methods are not inherited and thus cannot be overridden, but the question asks for preventing overriding of a method that is accessible; `private` methods are hidden, not prevented from overriding. Option B is wrong because `abstract` methods must be overridden by a subclass to provide an implementation, which is the opposite of preventing overriding. Option D is wrong because `static` methods are hidden, not overridden; they belong to the class rather than instances, and a subclass can declare a method with the same signature without overriding the parent's static method.

Why this answer

How to eliminate wrong answers

Option A is wrong because `int` is a 32-bit signed integer type used for whole numbers, not for storing characters; while it can hold a character's numeric code point, it is not the primitive type intended for character storage and requires explicit casting to be used as a character. Option B is wrong because `byte` is an 8-bit signed integer type with a range of -128 to 127, which is insufficient to represent the full Unicode character set (0 to 65,535) and cannot store most characters without data loss or overflow. Option D is wrong because `String` is a reference type (a class) that represents a sequence of characters, not a primitive type; it is used for strings of text, not a single character, and using it for a single character introduces unnecessary overhead and violates the requirement for a primitive data type.

Why this answer

How to eliminate wrong answers

Option A is wrong because setting breakpoints in the library requires the library to have been compiled with debug information; without it, the debugger cannot map bytecode to source lines, making breakpoints ineffective. Option C is wrong because adding logging statements in the application code only shows when the call is made and returns, but does not reveal where inside the library the NullPointerException occurs, so the root cause remains hidden. Option D is wrong because adding a try-catch around the library call and printing the stack trace will only show the same incomplete stack trace (without line numbers) that was already available; it does not add the missing debug information needed to pinpoint the exact location.

Why this answer

How to eliminate wrong answers

Option A is wrong because the method expects a single `double[]` argument, but `1.0, 2.0` are two separate `double` literals, not an array; Java does not support implicit array creation from a comma-separated list in a method call. Option C is wrong for the same reason: three separate `double` literals cannot be passed to a parameter that expects a single `double[]` reference. Option D is wrong because `{1.0, 2.0, 3.0}` is an array initializer syntax that is only valid in a declaration (e.g., `double[] arr = {1.0, 2.0, 3.0};`), not as a standalone expression in a method call.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because `Arrays.parallelSort(int[])` sorts the array in ascending order, not descending. Option B is wrong because `Collections.reverseOrder()` returns a `Comparator<T>` that works only with object arrays (e.g., `Integer[]`), not with primitive `int[]` arrays. Option D is wrong because `Arrays.sort()` for primitive arrays does not accept a `Comparator`; the overload that accepts a comparator works only with object arrays, and using a lambda with primitive arrays causes a compilation error.

Why this answer

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because a while loop requires manual initialization, condition checking, and increment of an index variable, making it more verbose and error-prone for simple array iteration. Option C is wrong because a switch statement is a selection construct for branching based on a single value, not a loop, and cannot iterate over array elements. Option D is wrong because a do-while loop, like the while loop, requires explicit index management and guarantees at least one execution, which is unnecessary overhead when the array may be empty.

Why this answer

How to eliminate wrong answers

Option B is wrong because 5 is the value of `x`, not the result of the ternary expression; the ternary operator does not return the variable itself. Option C is wrong because the ternary operator is a valid Java construct and the code compiles without error; the condition `x > 5` is a valid boolean expression. Option D is wrong because 10 is the value returned only when the condition is true, but here `x > 5` is false, so the false branch (20) is selected.

Why this answer

How to eliminate wrong answers

Option A is wrong because a multi-catch clause cannot contain exception types that are in a parent-child relationship; 'catch (FileNotFoundException | IOException e)' would cause a compilation error since FileNotFoundException is a subclass of IOException. Option B is wrong because catching IOException first makes the subsequent catch for FileNotFoundException unreachable, leading to a compilation error. Option D is wrong because catching Exception is too broad and would catch all exceptions, including unchecked ones like NullPointerException, which defeats the purpose of specifically handling FileNotFoundException and other IOExceptions.

Why this answer

How to eliminate wrong answers

Option B is wrong because it suggests the output is 0, but the array element at index 3 was never assigned and the exception prevents any output. Option C is wrong because it assumes the assignment succeeds, but the index is out of bounds, so the assignment never executes. Option D is wrong because the code compiles successfully; the error occurs only at runtime when the invalid index is accessed.

Why this answer

How to eliminate wrong answers

Option A is wrong because `int[]... numbers` declares a varargs of `int[]` arrays, meaning it expects an array of integer arrays, not a variable number of individual `int` values. Option C is wrong because `int numbers` is a single integer parameter, which cannot accept multiple arguments. Option D is wrong because `int[] numbers` accepts a single integer array parameter, not a variable number of individual `int` arguments.

Why this answer

How to eliminate wrong answers

Option A is wrong because 2variable starts with a digit, which violates the Java rule that identifiers cannot begin with a number. Option B is wrong because class is a reserved keyword in Java and cannot be used as an identifier. Option D is wrong because my-var contains a hyphen (-), which is not a valid character in Java identifiers; only letters, digits, dollar signs, and underscores are allowed.

Why this answer

How to eliminate wrong answers

Option A is wrong because `Arrays.sort(Object[])` does not require a `Comparator`; it uses the natural ordering defined by `Comparable`. Option C is wrong because the array cannot be sorted using natural order if the elements do not implement `Comparable`; the method will throw an exception instead. Option D is wrong because `Arrays.sort` does not use the `equals` method for ordering; it uses `compareTo` (from `Comparable`) or a provided `Comparator`.

Why this answer

How to eliminate wrong answers

Option A is wrong because a return statement would exit the entire method, not just the outer loop, which is too drastic and may leave resources unclosed or skip necessary cleanup. Option B is wrong because a continue statement with a label skips the current iteration of the labeled loop and continues with the next iteration, rather than exiting the loop entirely. Option D is wrong because a plain break statement inside the inner loop only terminates that inner loop, not the outer loop, so the outer loop continues executing.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because TreeSet sorts elements by their natural order or a provided comparator, not by insertion order, and it does not allow duplicates. Option B is wrong because LinkedList maintains insertion order but has slower iteration performance due to node-based traversal and higher memory overhead compared to ArrayList. Option C is wrong because HashSet does not guarantee any order; it uses hash codes to store elements and may reorder them arbitrarily.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because it suggests the output is 'B A C', which would occur if constructors were called in reverse order or if `super()` was not used correctly, but Java always calls parent constructors first. Option C is wrong because it suggests 'A C B', which would happen if `C`'s constructor printed before `B`'s, but `super()` in `C` invokes `B`'s constructor before `C`'s own print statement. Option D is wrong because it suggests 'C B A', which would be the order of a destructor chain or if constructors were called from child to parent, but Java constructors execute from the top of the hierarchy down.

Why this answer

How to eliminate wrong answers

Option B is wrong because a syntax error in the try block would be caught at compile time, not at runtime as a NullPointerException. Option C is wrong because an incorrect classpath prevents class loading, resulting in a ClassNotFoundException or NoClassDefFoundError, not a NullPointerException. Option D is wrong because a missing import statement causes a compile-time error (e.g., 'cannot find symbol'), not a runtime NullPointerException.

Why this answer

How to eliminate wrong answers

Option A is wrong because it suggests the value remains 10, but the arithmetic operation `s + 5` would compute 15, not 10, and the code fails to compile before any assignment occurs. Option B is wrong because the error is a compile-time error, not a runtime exception; Java catches type mismatch issues during compilation. Option C is wrong because although the mathematical result is 15, the code does not compile due to the lossy conversion from `int` to `short`, so no assignment occurs.

Why this answer

How to eliminate wrong answers

Option B is wrong because `length` is 5, which would attempt to copy 5 elements into `dest` that only has 3 elements, causing an `ArrayIndexOutOfBoundsException`. Option C is wrong because `srcPos` is 1, so it copies elements starting from index 1 (values 2,3,4) instead of the first three elements (1,2,3). Option D is wrong because `destPos` is 1, so it would place the copied elements starting at index 1 of `dest`, leaving index 0 unchanged and potentially causing an `ArrayIndexOutOfBoundsException` when writing beyond the array bounds.

Why this answer

How to eliminate wrong answers

Option B is wrong because a NullPointerException would only occur if the ternary operator attempted to auto-unbox a null Integer to int, but the condition (a != null) is false, so the expression evaluates to the int literal 0, not to a. Option C is wrong because the code compiles successfully; the ternary operator is syntactically valid and both operands are compatible with int assignment. Option D is wrong because b is a primitive int, which cannot hold a null value; the output is the integer 0, not the string 'null'.

Why this answer

How to eliminate wrong answers

Option B (11) is wrong because it incorrectly assumes both increments use the same intermediate value (e.g., 5 + 6). Option C (10) is wrong because it might assume both increments use the original value (5 + 5) or misapply operator precedence. Option D (compilation error) is wrong because the expression is syntactically valid in Java; post-increment and pre-increment can be used together in an expression without error.

Why this answer

How to eliminate wrong answers

Option B is wrong because it assumes all numbers are concatenated as strings from the start, ignoring that `1 + 2` is evaluated as integer addition before any string context. Option C is wrong because it incorrectly includes literal quotes in the output, which Java never prints; the `+` operator does not produce quote characters. Option D is wrong because it sums all numbers as integers (1+2+3+4+5=15), ignoring that the string `"3"` forces subsequent operations to be string concatenation, not arithmetic.

Why this answer

How to eliminate wrong answers

Option A is wrong because the `-d` flag specifies the output directory, not the source directory; the compiler searches for source files in the path provided after the `-d` option (here, `src/com/example/App.java`), not in `bin`. Option C is wrong because `javac` does not create JAR files; JAR creation is done with the `jar` tool, not the `javac` compiler. Option D is wrong because the command does not include any module-related options (like `--module-source-path` or `-p`) and compiles a single class file, not a named module; named modules require a `module-info.java` file and specific module path settings.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because it ignores the fall-through from case 2 to case 3, which prints 'Three' as well. Option B is wrong because the default case is only executed if no matching case is found; here case 2 matches, so default is skipped. Option C is wrong because a missing break does not cause compilation failure; it is syntactically valid and results in fall-through behavior.

Why this answer

How to eliminate wrong answers

Option A is wrong because `super()` cannot be placed anywhere; it must be the first statement, or the compiler will report an error. Option C is wrong because placing `super()` at the end would attempt to initialize the superclass after subclass code, violating Java's constructor chaining rules and causing a compilation failure. Option D is wrong because `this.super()` is invalid syntax; `super()` is a standalone keyword call, not a method on `this`.

Why this answer

How to eliminate wrong answers

Option B is wrong because the code does not compile, so it never executes to check if x equals 5. Option C is wrong because a compilation error occurs before any runtime output, so there is no 'no output' scenario. Option D is wrong because even if the code compiled (which it does not), the assignment would always set x to 5, but the condition would still be a non-boolean type, causing a compilation error; thus it never prints anything.

Why this answer

How to eliminate wrong answers

Option A is wrong because a do-while loop guarantees at least one iteration before checking the condition, which is unnecessary and could cause the loop to process a negative number before stopping. Option C is wrong because an enhanced for loop with return would exit the entire method, not just the loop, which is an overly broad and incorrect control flow for this scenario. Option D is wrong because a while loop with continue would skip the current iteration and proceed to the next, not stop the loop entirely when a negative number is found.

Why this answer

Why this answer

Why this answer

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because `String[] arr = new String[] {"A", "B", "C"};` is syntactically valid but it uses an anonymous array creation expression with an explicit `new` keyword, which is not the simplest or most direct way to declare and initialize in one line; however, the question asks for the correct declaration and initialization, and while this syntax works, it is not the standard shorthand that the exam expects (the exam considers the array initializer without `new` as the correct form for this context). Option B is wrong because `String[] arr = ("A", "B", "C");` uses parentheses, which is invalid syntax in Java for array initialization; parentheses are used for grouping expressions or method calls, not for array literals. Option C is wrong because `String[] arr = ["A", "B", "C"];` uses square brackets, which is invalid syntax in Java for array initialization; square brackets are used for array indexing or type declaration, not for defining array contents.

Why this answer

How to eliminate wrong answers

Option B is wrong because an array of primitive int cannot store null; only object arrays can have null elements, and accessing an out-of-bounds index throws an exception, not returns null. Option C is wrong because Java does not return -1 for out-of-bounds array access; that behavior is specific to methods like String.indexOf(), not array indexing. Option D is wrong because while uninitialized int array elements default to 0, accessing an invalid index does not return the default value—it throws an exception.

Why this order

Why this answer

How to eliminate wrong answers

Option A is wrong because 'null' is the default value for object references, not for primitive types like boolean. Option B is wrong because 'true' is not the default; the JLS explicitly states that the default for boolean is false. Option D is wrong because 0 is the default for numeric primitives (int, long, etc.), not for boolean, which is not a numeric type and cannot be assigned 0.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because manually reviewing all possible callers is time-consuming and error-prone, especially in a large codebase where the method is called from many places, and it does not guarantee identifying the exact runtime path that triggers the exception. Option C is wrong because static analysis tools can detect potential array index issues but cannot determine the specific runtime call path that leads to the exception, as they analyze code without execution context. Option D is wrong because adding log statements requires modifying code, recompiling, and re-running the test, which is less efficient than debugging and may not capture the exact state at the point of failure without extensive logging.

Why this answer

How to eliminate wrong answers

Option A is wrong because `String` is a reference type used for sequences of characters, not a single character; using it for a single character introduces unnecessary object overhead. Option C is wrong because `byte` is an 8-bit integer type with a range of -128 to 127, which cannot directly represent most Unicode characters like 'A' without casting and loss of character semantics. Option D is wrong because `int` is a 32-bit integer type, which can technically hold a character's numeric value but is not intended for character storage and lacks the semantic clarity and type safety of `char`.

Why this answer

Why this answer

How to eliminate wrong answers

Option A is wrong because it suggests the output is '2', but the continue statement skips printing 2, so 2 is not output. Option B is wrong because the code compiles successfully; the enhanced for loop and continue are valid Java syntax. Option D is wrong because it includes '2' in the output, but the continue statement prevents 2 from being printed, so the output is '13', not '123'.

Why this answer

How to eliminate wrong answers

Option A is wrong because it attempts to catch IOException and FileNotFoundException in a multi-catch block, but FileNotFoundException is a subclass of IOException, making the catch for FileNotFoundException unreachable and causing a compilation error. Option C is wrong for the same reason as A — the order does not matter; the compiler still detects the subclass relationship and rejects the multi-catch. Option D is wrong because it places the more specific exception (FileNotFoundException) after the more general one (IOException), which means the FileNotFoundException catch block will never be executed (unreachable code), leading to a compilation error.