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

Question 1

Match each Java module directive to its description.

Accepted Answer

requires: Specifies a dependency on another module.. Correct matches: requires specifies dependencies, exports grants compile-time access, opens enables reflective access, provides declares service implementations. Common confusion is between exports and opens due to their related but distinct roles.

Answer

exports: Allows reflective access to a package.

Answer

opens: Makes a package accessible to other modules.

Question 2

Match each I/O stream class to its description.

Accepted Answer

FileInputStream: Reads bytes from a file. The correct matches are based on the direction (read vs write) and type (byte vs character) of the stream. FileInputStream reads bytes; FileOutputStream writes bytes. BufferedReader reads characters with buffering; BufferedWriter writes characters with buffering.

Answer

FileInputStream: Writes bytes to a file

Answer

BufferedReader: Writes text to a character-output stream

Question 3

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.. 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 4

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 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 5

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 6

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 7

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. 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 8

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 9

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 do-while loop executes the body first (x--), then checks the condition x < 10. After the first iteration, x becomes 9, and the condition (9 < 10) is true. As x continues to decrease, it will always be less than 10, so the condition remains true forever. This results in an infinite loop; the program never reaches the print statement. Therefore, no output is produced, and none of the options (3, 2, 1) are correct.

Answer

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

Answer

2

Answer

1

Question 10

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 11

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 Java switch statements use fall-through: after case 10 matches and prints 'ten ', execution continues into the default label (printing 'default ') and then into case 20 (printing 'twenty '), yielding 'ten default twenty '. Option E is correct because the code compiles without error and runs, and the observed output is precisely the result of fall-through behavior rather than any break statements. Option A is wrong because default is not skipped when a matching case exists; without a break, control falls into default. Option B is wrong because case 20 is not skipped; fall-through reaches it and prints 'twenty '. Option C is wrong because Java does not require default to be the last case; default may appear anywhere in the switch.

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.

Question 12

What is the output when this code is executed?

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

Accepted Answer

Two Three. The switch statement matches the value 2, so it executes the case 'Two' block, which prints 'Two ' and then falls through to the next case because there is no break statement. The case 'Three' block prints 'Three ' and then breaks, exiting the switch. The default case is skipped because a matching case was found and the break in case 'Three' prevents further fall-through. Thus, the output is 'Two Three '.

Answer

Two

Answer

Two Three Default

Answer

One Two Three

Question 13

What is the likely cause of this compilation error?
```java
String day = "Monday";
int dayNum = switch (day) {
    case 1 -> 1;
    case 2 -> 2;
    default -> 0;
};
System.out.println(dayNum);
```

Accepted Answer

The switch selector is a String but case labels are int constants.. In a Java switch expression, the selector type and case label types must be compatible. If the selector is a String, the case labels must be String constants; int constants would cause a compilation error due to type mismatch. Options A, B, and C describe syntax issues that are not the primary cause here.

Answer

The switch expression uses arrow syntax but the keys are not unique.

Answer

The switch expression is missing a default case.

Answer

The switch expression is not assigned to a variable.

Question 14

Given: for(int i=0; i<3; i++) { for(int j=0; j<3; j++) { if(i==1 && j==1) break; } } What is the value of i after the outer loop completes?

Accepted Answer

3. The outer loop variable `i` increments from 0 to 2. When `i` is 1 and `j` is 1, the `break` statement exits only the inner `for` loop, not the outer loop. The outer loop continues to its next iteration, incrementing `i` to 2, then to 3. When `i` becomes 3, the outer loop condition `i < 3` fails, so the loop terminates. Thus, after the outer loop completes, `i` is 3.

Answer

1

Answer

2

Answer

4

Question 15

Given: Object obj = "Hello"; String result = switch(obj) { case String s -> "String of length " + s.length(); case Integer i -> "Integer"; default -> "Unknown"; }; What is result?

Accepted Answer

"String of length 5". The switch expression uses pattern matching with type patterns. The runtime type of obj is String, so the first case matches, binding the value to s and executing the expression "String of length " + s.length(). Since s is "Hello", s.length() returns 5, so result is "String of length 5". Option C is correct.

Answer

"Unknown"

Answer

Compilation error

Answer

"Integer"