OCP Exception Handling and Assertions Questions and Answers

Question 1

Examine the following code which uses a try-with-resources statement. What is the output when this code is executed?

```java
class Door implements AutoCloseable {
    private String name;
    public Door(String name) { this.name = name; System.out.println(name + " opened"); }
    @Override
    public void close() { System.out.println(name + " closed"); }
}

public class Test {
    public static void main(String[] args) {
        try (Door front = new Door("Front"); Door back = new Door("Back")) {
            System.out.println("Walking through doors");
        } 
    }
}
```

Accepted Answer

Front opened
Back opened
Walking through doors
Back closed
Front closed

Answer

In a try-with-resources statement, resources are initialized in the order they are declared. However, they are closed in the reverse order of their declaration. Therefore, 'Front' is opened first, then 'Back'. After the try block executes, 'Back' is closed first, and then 'Front' is closed.

Question 2

What is the final value returned by the `checkValue` method when executed?

```java
public class Test {
    public static int checkValue() {
        try {
            System.out.println("Executing try");
            return 10;
        } catch (Exception e) {
            System.out.println("Executing catch");
            return 20;
        } finally {
            System.out.println("Executing finally");
            return 30;
        }
    }

public static void main(String[] args) {
        System.out.println("Returned: " + checkValue());
    }
}
```

Accepted Answer

30

Answer

The `finally` block is always executed after the `try` block exits. If a `finally` block includes a `return` statement, it will override any value that was about to be returned from the `try` or `catch` block. In this case, the `try` block prepares to return 10, but the `finally` block executes and its `return` statement overrides the previous one, causing the method to return 30.

Question 3

Which of the following statements about the `assert` keyword in Java is true?

Accepted Answer

Assertions can be enabled at runtime using the `-ea` flag and are primarily intended for debugging and testing.

Answer

Assertions are disabled by default and are not meant to replace standard exception handling. They are intended for developers to verify internal invariants during development and testing. They can be enabled with the JVM flag `-ea` or `-enableassertions`. If an assertion fails, it throws an `AssertionError`, which is a subclass of `Error` (an unchecked throwable), not a checked exception.

Question 4

A method is declared to throw both `java.io.IOException` and `java.sql.SQLException`. Which of the following `catch` clauses is the correct and most concise way to handle both of these distinct exception types in a single block?

Accepted Answer

```java
catch (IOException | SQLException e) { /* ... */ } 
```

Answer

Since Java 7, a single `catch` block can handle multiple exception types using the multi-catch syntax, which separates the exception types with a single vertical bar `|`. The exception variable (`e` in this case) is implicitly final. While catching the superclass `Exception` would also work, it is less specific and therefore not the *best* answer for handling only these two specific types.

Question 5

Which of the following exceptions is a checked exception that the Java compiler requires to be handled or declared?

Accepted Answer

java.io.FileNotFoundException

Answer

`FileNotFoundException` is a subclass of `IOException`, which is a checked exception. The Java compiler enforces that checked exceptions must be either caught in a try-catch block or declared in the method signature with a `throws` clause. The other options (`NullPointerException`, `ArrayIndexOutOfBoundsException`, `ClassCastException`) are all subclasses of `RuntimeException` and are therefore unchecked exceptions.

(OCP) Oracle Certified Professional Practice Test

(OCP) Oracle Certified Professional Practice Test

OCP Exception Handling and Assertions Questions and Answers