1Z0-829 Controlling Program Flow Practice Test 2 — 15 Questions

Question 1

A Java developer is writing a batch processing application that reads records from a database and processes them. The processing must continue even if some records cause exceptions (e.g., data conversion errors). However, the application must log each failed record and its error, then continue with the next record. The developer uses a for loop to iterate over a list of records. Inside the loop, a try-catch block wraps the processing logic. After implementing, the developer notices that when an exception occurs, the loop terminates prematurely instead of continuing. The code structure is:

List<Record> records = fetchRecords();

for (Record rec : records) {

try { process(rec);

} catch (Exception e) {

log.error("Failed to process: " + rec.getId(), e);

}
}

What is the most likely reason for the premature termination?

List<Record> records = fetchRecords();
for (Record rec : records) {
    try {
        process(rec);
    } catch (Exception e) {
        log.error("Failed to process: " + rec.getId(), e);
    }
}

What is the most likely reason for the premature termination?

Accepted Answer

The process() method throws an Error instead of an Exception.. The code catches `Exception`, but `Error` (and its subclasses like `OutOfMemoryError`, `StackOverflowError`, or custom `Error` types) are not subclasses of `Exception`. In Java, `Throwable` has two main branches: `Exception` (including `RuntimeException`) and `Error`. Since `Error` is not caught by `catch (Exception e)`, it propagates up and terminates the loop. This is the most likely reason for premature termination because the developer assumed all failures would be `Exception` types.

Answer

The records list contains null elements, causing a NullPointerException that is not caught.

Answer

The log.error() method itself throws an unchecked exception that is not caught.

Answer

The try-catch block is incorrectly placed inside the for loop, causing the loop to break on any exception.

Question 2

Order the steps to properly handle resources using try-with-resources in Java.

Question 3

Order the steps to handle checked exceptions in a method that throws IOException.

Question 4

Match each Java module directive to its description.

Question 5

Match each I/O stream class to its description.

Question 6

A developer writes a method that processes a grade and returns a message using a switch expression. The code is:

```java
public static String getMessage(int grade) {
    return switch (grade) {
        case 90, 80 -> "Excellent";
        case 70, 60 -> "Good";
        case 50 -> "Pass";
        default -> "Fail";
    };
}
```

Which statement is correct about this code?

Accepted Answer

The code compiles and runs correctly, returning the appropriate message.. Option C is correct because the switch expression uses the arrow form with a list of constants per case, which is valid syntax in Java 14+. The arrow form does not require a 'yield' statement when the right side is a single expression or block; here, each case yields a string literal directly. The 'default' clause is mandatory in a switch expression to cover all possible values, and it is correctly included.

Answer

The code does not compile because the switch expression must be enclosed in parentheses.

Answer

The code does not compile because the arrow form requires a 'yield' statement.

Answer

The code does not compile because 'default' is not allowed in a switch expression.

Question 7

Given the following code snippet:

```java
outer:
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (i == 1 && j == 1) {
            break outer;
        }
        System.out.print(i + "-" + j + " ");
    }
}
```

What is the output?

Accepted Answer

0-0 0-1 0-2 1-0. The correct answer is B because the labeled `break outer;` statement exits the outer loop entirely when `i == 1` and `j == 1`. Before that condition is met, the inner loop prints pairs for `i=0` (all j values 0,1,2) and for `i=1` with `j=0`. When `i=1` and `j=1`, the break occurs, so `1-1` is never printed, and the outer loop stops, preventing any further iterations.

Answer

0-0 0-1 0-2 1-0 1-1 1-2

Answer

0-0 0-1 0-2 1-0 2-0 2-1 2-2

Answer

0-0 0-1 0-2 1-0 1-1

Question 8

Consider the following code:

```java
boolean a = true, b = false, c = false;
if (a && b || c) {
    System.out.println("True");
} else {
    System.out.println("False");
}
```

What is the output?

Accepted Answer

False. The expression `a && b || c` evaluates as `(a && b) || c` due to operator precedence (`&&` has higher precedence than `||`). With `a=true`, `b=false`, `c=false`, `(true && false)` is `false`, then `false || false` is `false`, so the `else` branch prints "False". Option B is correct.

Answer

The code does not compile because of invalid boolean expression.

Answer

The output cannot be determined without runtime values.

Answer

True

Question 9

A method uses an enhanced for loop to iterate over a list of strings and prints each string. The code is:

```java
List<String> list = List.of("A", "B", "C");
for (String s : list) {
    if (s.equals("B")) {
        break;
    }
    System.out.print(s);
}
```

What is the result?

Accepted Answer

A. The enhanced for loop iterates over the list, and when it encounters the string "B", the break statement immediately exits the loop. Therefore, only "A" is printed before the loop terminates. Option C is correct because the output is just "A".

Answer

The code throws a ConcurrentModificationException.

Answer

ABC

Answer

AB

Question 10

Given the following switch statement:

```java
int x = 2;
switch (x) {
    default:
        System.out.print("default ");
    case 1:
        System.out.print("1 ");
    case 2:
        System.out.print("2 ");
    case 3:
        System.out.print("3 ");
        break;
    case 4:
        System.out.print("4 ");
}
```

What is the output?

Accepted Answer

2 3. Option C is correct because the switch statement starts execution at the matching case (case 2) and then falls through to subsequent cases until a break statement is encountered. Since case 2 has no break, it prints "2 ", then falls through to case 3, prints "3 ", and the break terminates the switch. The default case is not executed because a matching case was found before it.

Answer

2

Answer

2 3 4

Answer

default 1 2 3

Question 11

What is the output of the following code?

```java
int i = 5;
while (i > 0) {
    System.out.print(i + " ");
    i--;
}
```

Accepted Answer

5 4 3 2 1. The while loop runs as long as i > 0. Starting with i = 5, each iteration prints the current value of i followed by a space, then decrements i by 1. The loop stops when i becomes 0, so the output is '5 4 3 2 1 '.

Answer

The code does not compile because i is not declared final.

Answer

5 4 3 2

Answer

4 3 2 1

Question 12

Consider the following do-while loop:

```java
int x = 10;
do {
    x--;
} while (x < 10);
System.out.println(x);
```

What is printed?

Accepted Answer

3. The loop executes body first: x becomes 2, condition (2<3) true, execute again: x becomes 3, condition (3<3) false, exit. Print x which is 3.

Answer

The loop does not compile because x is not declared final.

Answer

2

Answer

1

Question 13

Given the following code:

```java
outer:
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (i == 1) {
            continue outer;
        }
        System.out.print(i + " " + j + " ");
    }
}
```

What is the output?

Accepted Answer

0-0 0-1 0-2 2-0 2-1 2-2. The correct answer is D because when i equals 1, the continue outer statement skips the entire inner loop for that iteration, so no output is produced for i=1. The outer loop continues with i=2, printing all j values (0,1,2) for i=2, resulting in the output: 0 0 0 1 0 2 2 0 2 1 2 2.

Answer

0-0 0-1 0-2 1-0 2-0 2-1 2-2

Answer

0-0 0-1 0-2 1-0 1-1 1-2 2-0 2-1 2-2

Answer

0-0 0-1 0-2 2-0 2-1 2-2

Question 14

Which of the following correctly uses a switch expression with multiple constants per case?

```java
int day = 2;
String result = switch (day) {
    case 1, 2, 3 -> "Weekday";
    case 6, 7 -> "Weekend";
    default -> "Invalid";
};
```

What is the value of result?

Accepted Answer

Weekday. The switch expression correctly uses multiple constants per case with the arrow syntax. Since day is 2, it matches case 1, 2, 3, so the expression evaluates to "Weekday". The switch expression is exhaustive (covers all possible int values via the default branch), so it compiles and runs without error.

Answer

The code does not compile because multiple constants are not allowed.

Answer

Invalid

Answer

Weekend

Question 15

Which TWO correctly describe the behavior of the following code?

```java
int x = 10;
switch (x) {
    case 10: System.out.print("ten ");
    default: System.out.print("default ");
    case 20: System.out.print("twenty ");
}
```

Accepted Answer

The output is 'ten default twenty '.. Option D is correct because in a Java switch statement, once a matching case is found, all subsequent cases (including the default case) are executed in order until a break statement is encountered. Here, case 10 matches, so it prints 'ten ', then falls through to default (prints 'default '), then falls through to case 20 (prints 'twenty '), producing 'ten default twenty '. This is known as fall-through behavior.

Answer

The default case is never executed because a matching case exists.

Answer

The output is 'ten default ' because case 20 is skipped.

Answer

The code does not compile because default must be the last case.