Chapter 4 Making Decisions Flashcards

Question

**Switch Control Flow** ``` var dayOfWeek = 5; switch(dayOfWeek) { case 0: System.out.println("Sunday"); default: System.out.println("Weekday"); case 6: System.out.println("Saturday"); break; } ```

Answer 1

This code looks a lot like the previous example. Notice that we used a var for the switch variable, which is allowed because it resolves to an int by the compiler. Next, two of the break statements have been removed, and the order has been changed. This means that for the given value of dayOfWeek, 5, the code will jump to the default block and then execute all of the proceeding case statements in order until it finds a break statement or finishes the switch statement: **Weekday Saturday ** The order of the case and default statements is now important since placing the default statement at the end of the switch statement would cause only one word to be output. What if the value of dayOfWeek was 6 in this example? Would the default block still be executed? The output of this example with dayOfWeek set to 6 would be as follows: **Saturday** Even though the default block was before the case block, only the case block was executed. If you recall the definition of the default block, it is branched to only if there is no matching case value for the switch statement, regardless of its position within the switch statement. Finally, if the value of dayOfWeek was 0, all three statements would be output: **Sunday Weekday Saturday ** Notice that in this last example, the default statement is executed since there was no break statement at the end of the preceding case block. While the code will not branch to the default statement if there is a matching case value within the switch statement, it will execute the default statement if it encounters it after a case statement for which there is no terminating break statement.

Answer 2

First off, the values in each **case statement must be compile-time constant values of the same data type as the switch value.** This means you can use only **literals, enum constants, or final constant variables of the same data type.** By **final constant**, we mean that the **variable must be marked with the final modifier and initialized with a literal value in the same expression in which it is declared.**

Answer 3

The ***bananas*** variable is **marked final**, and its **value is known at compile-time**, so it is **valid**. The ***apples*** variable is **not marked final**, even though its value is known, so it is **not permitted**. The next two case statements, with values ***getCookies()*** and ***cookies***, do not compile because methods are not evaluated until runtime, so they cannot be used as the value of a case statement, even if one of the values is stored in a final variable. The last case statement, with value **3 * 5**, does compile, as **expressions are allowed as case values**, **provided the value can be resolved at compile-time.** They also must be able to **fit in the switch data type without an explicit cast**. We’ll go into that in more detail shortly. Next, the **data type for case statements must all match the data type of the switch variable.** For example, you **can’t have a case statement of type String**, if the **switch statement variable is of type int**, since the **types are incomparable.**

Answer 4

The first case statement, "Test", compiles without issue since it is a **String literal** and is a good example of how a return statement, like a break statement, can be used to exit the switch statement early. The second case statement does not compile because ***middleName* is not a constant value**, despite having a known value at this particular line of execution. If a final modifier was added to the declaration of middleName, this case statement would have compiled. The third case statement compiles without issue because ***suffix* is a final constant variable.** In the fourth case statement, despite ***lastName* being final, it is not constant as it is passed to the function**; therefore, this line does not compile as well. Finally, the last three case statements do not compile because **none of them has a matching type of String**, the last one being an enum value.

Answer 5

switch statements support numeric promotion that does not require an explicit cast. As you may recall from our discussion of numeric promotion and casting in Chapter 3, the compiler can easily cast small from int to short at compile-time because the value 15 is small enough to fit inside a short. This would not be permitted if small was not a compile-time constant. Likewise, it can convert the expression 1+2 from int to short at compile-time. On the other hand, 1_000_000 is too large to fit inside of short without an explicit cast, so the last case statement does not compile.

Answer 6

A **loop** is a repetitive control structure that can execute a statement of code multiple times in succession. By making use of variables being able to be assigned new values, each repetition of the statement may be different.

Answer 7

``` int counter = 0; while (counter < 10) { double price = counter * 10; System.out.println(price); counter++; } ```

Answer 8

The answer? Zero! On the first iteration of the loop, the condition is reached, and the loop exits. This is why while loops are often used in places where you expect zero or more executions of the loop. Simply put, the body of the loop may not execute at all or may execute many times.

Answer 9

do/while loop guarantees that the statement or block will be executed at least once.

Answer 10

while loop is executed zero or more times, a do/while loop is executed one or more times.

Answer 11

``` int lizard = 0; do { lizard++; } while(false); System.out.println(lizard); // 1 ``` do/while loop purposely orders the body before the conditional expression so that the body will be executed at least once. Java will execute the statement block first and then check the loop condition. Even though the loop exits right away, the statement block is still executed once, and the program prints 1.

Answer 12

The single most important thing you should be aware of when you are using any repetition control structure is to make sure they always terminate! Failure to terminate a loop can lead to numerous problems in practice including overflow exceptions, memory leaks, slow performance, and even bad data.

Answer 13

The **variable pen is never modified, so the expression (pen < 10) will always evaluate to true**. The result is that the loop will never end, creating what is commonly referred to as an infinite loop. **An infinite loop is a loop whose termination condition is never reached during runtime.**

Answer 14

In practice, infinite loops can be used to monitor processes that exist for the life of the program—for example, a process that wakes up every 30 seconds to look for work to be done and then goes back to sleep afterward. When creating an infinite loop like this, you need to make sure there are only a fixed number of them created by the application, or you could run out of memory. You also have to make sure that there is a way to stop them, often as part of the application shutting down. Finally, there are modern alternatives to creating infinite loops, such as using a scheduled thread executor, that are well beyond the scope of the exam. If you’re not familiar with how to create and execute multiple processes at once, don’t worry, you don’t need to be for this exam. When you continue on to exam 1Z0-816, you will study these topics as part of concurrency.

Answer 15

1. basic for loop 1. enhanced for loop, for-each loop

Answer 16

A ***basic*** for **loop** has the same conditional **boolean expression** and **statement**, or **block of statements**, as the while loops, as well as two new sections: an ***initialization block*** and an ***update statement***.

Answer 17

code does not compile because the loop variable i is referenced outside the loop

Answer 18

1. Creating an **Infinite Loop** ``` for( ; ; ) System.out.println("Hello World"); ``` Although this for loop may look like it does not compile, it will in fact compile and run without issue. It is actually an infinite loop that will print the same statement repeatedly. This example reinforces the fact that the **components of the for loop are each optional**. Note that the **semicolons separating the three sections are require**d, as **for( ) without any semicolons will not compile.** 2. Adding Multiple Terms to the for Statement ``` int x = 0; for(long y = 0, z = 4; x < 5 && y < 10; x++, y++) { System.out.print(y + " "); } System.out.print(x + " "); ``` This code demonstrates three variations of the for loop you may not have seen. First, you can declare a variable, such as x in this example, before the loop begins and use it after it completes. Second, your initialization block, boolean expression, and update statements can include extra variables that may or may not reference each other. For example, z is defined in the initialization block and is never used. Finally, the update statement can modify multiple variables. This code will print the following when executed: 0 1 2 3 4 5 3. Redeclaring a Variable in the Initialization Block ``` int x = 0; for(int x = 4; x < 5; x++) { // DOES NOT COMPILE System.out.print(x + " "); } ``` This example looks similar to the previous one, but it does not compile because of the initialization block. The difference is that x is repeated in the initialization block after already being declared before the loop, resulting in the compiler stopping because of a duplicate variable declaration. We can fix this loop by removing the declaration of x from the for loop as follows: ``` int x = 0; for(x = 0; x < 5; x++) { System.out.print(x + " "); } ``` Note that this variation will now compile because the initialization block simply assigns a value to x and does not declare it. 4. Using Incompatible Data Types in the Initialization Block ``` int x = 0; for(long y = 0, int z = 4; x < 5; x++) { // DOES NOT COMPILE System.out.print(y + " "); } ``` Like the third example, this code will not compile, although this time for a different reason. The variables in the initialization block must all be of the same type. In the multiple terms example, y and z were both long, so the code compiled without issue, but in this example they have differing types, so the code will not compile. 5. Using Loop Variables Outside the Loop ``` for(long y = 0, x = 4; x < 5 && y < 10; x++, y++) { System.out.print(y + " "); } System.out.print(x); // DOES NOT COMPILE ``` We covered this already at the start of this section, but this is so important for passing the exam that we discuss it again here. If you notice, x is defined in the initialization block of the loop and then used after the loop terminates. Since x was only scoped for the loop, using it outside the loop will cause a compiler error.

Answer 19

All three of these examples compile, as Java does let you modify loop variables, whether they be in for, while, or do/while loops. The first two examples create infinite loops, as loop conditions i<10 and j<10 are never reached, independently. In the first example, i is reset during every loop to 0, then incremented to 1, then reset to 0, and so on. In the second example, j is decremented to 0, then incremented to 1, then decremented to 0, and so on. The last example executes the loop exactly 10 times, so it is valid, albeit a little unusual. Java does allow modification of loop variables, but you should be wary if you see questions on the exam that do this. While it is normally straightforward to look at a for loop and get an idea of how many times the loop will execute, once we start modifying loop variables, the behavior can be extremely erratic. This is especially true when nested loops are involved, which we cover later in this chapter.

Answer 20

the enhanced for loop, or for-each loop as we like to call it. **The for-each loop is a specialized structure designed to iterate over arrays and various Collection Framework classes**

Answer 21

The code will compile and print the following: Lisa, Kevin, Roger,

Answer 22

This code will compile and print the same values: Lisa, Kevin, Roger,

Answer 23

In this example, the String names is not an array, nor does it define a list of items, so the compiler will throw an exception since it does not know how to iterate over the String. As a developer, you could iterate over each character of a String, but this would require using the charAt() method, which is not compatible with a for-each loop. The charAt() method, along with other String methods, will be covered in Chapter 5.

Answer 24

This code will fail to compile because the left side of the for-each statement does not define an instance of String. Notice that in this last example, the array is initialized with three null pointer values. In and of itself, that will not cause the code to not compile, as a corrected loop would just output null three times.

Answer 25

This sample code would output the following: Lisa, Kevin, Roger ``` List names = new ArrayList(); names.add("Lisa"); names.add("Kevin"); names.add("Roger"); for(int i=0; i 0) { System.out.print(", "); } System.out.print(name); } ``` This sample code would output the following: 2, 3, Notice that we skip the first index of the array, since value[-1] is not defined and would throw an IndexOutOfBoundsException error if called with i=0. When comparing n elements of a list with each other, our loop should be executed n-1 times. ``` int[] values = new int[3]; values[0] = 1; values[1] = Integer.valueOf(3); values[2] = 6; for(int i=1; i

Answer 26

how for-each loops are converted to for loops by the compiler. When for-each was introduced in Java 5, it was added as a compile-time enhancement. This means that Java actually converts the for-each loop into a standard for loop during compilation. ex: ``` for(String name : names) { System.out.print(name + ", "); } for(int i=0; i < names.length; i++) { String name = names[i]; System.out.print(name + ", "); } ``` For objects that inherit Iterable, there is a different, but similar, conversion. For example, assuming values is an instance of List, the following two loops are equivalent: ``` for(int value : values) { System.out.print(value + ", "); } for(Iterator i = values.iterator(); i.hasNext(); ) { int value = i.next(); System.out.print(value + ", "); } ``` Notice that in the second version, there is no update statement in the for loop as next() both retrieves the next available value and moves the iterator forward.

Answer 27

how for-each loops are converted to for loops by the compiler. When for-each was introduced in Java 5, it was added as a compile-time enhancement. This means that Java actually converts the for-each loop into a standard for loop during compilation.

Answer 28

A nested loop is a loop that contains another loop including while, do/while, for, and for-each loops. ``` int[][] myComplexArray = {{5,2,1,3},{3,9,8,9},{5,7,12,7}}; for(int[] mySimpleArray : myComplexArray) { for(int i=0; i

Answer 29

The first time this loop executes, the inner loop repeats until the value of hungryHippopotamus is 4. The value will then be decremented to 3, and that will be the output at the end of the first iteration of the outer loop. On the second iteration of the outer loop, the inner do/while will be executed once, even though hungryHippopotamus is already not greater than 5. As you may recall, do/while statements always execute the body at least once. This will reduce the value to 1, which will be further lowered by the decrement operator in the outer loop to 0. Once the value reaches 0, the outer loop will terminate. The result is that the code will output the following: 3, 0, The examples in the rest of this section will include many nested loops. You will also encounter nested loops on the exam, so the more practice you have with them, the more prepared you will be.

Answer 30

label is an optional pointer to the head of a statement that allows the application flow to jump to it or break from it. It is a single identifier that is proceeded by a colon (:). ``` int[][] myComplexArray = {{5,2,1,3},{3,9,8,9},{5,7,12,7}}; OUTER_LOOP: for(int[] mySimpleArray : myComplexArray) { INNER_LOOP: for(int i=0; i

Answer 31

a break statement transfers the flow of control out to the enclosing statement. break statement can take an optional label parameter. Without a label parameter, the break statement will terminate the nearest inner loop it is currently in the process of executing. The optional label parameter allows us to break out of a higher-level outer loop.

Answer 32

When executed, this code will output the following: Value 2 found at: (1,1) In particular, take a look at the statement break PARENT_LOOP. This statement will break out of the entire loop structure as soon as the first matching value is found. Now, imagine what would happen if we replaced the body of the inner loop with the following: ``` if(list[i][j]==searchValue) { positionX = i; positionY = j; break; } ``` How would this change our flow, and would the output change? Instead of exiting when the first matching value is found, the program will now only exit the inner loop when the condition is met. In other words, the structure will now find the first matching value of the last inner loop to contain the value, resulting in the following output: Value 2 found at: (2,0) Finally, what if we removed the break altogether? ``` if(list[i][j]==searchValue) { positionX = i; positionY = j; } ``` In this case, the code will search for the last value in the entire structure that has the matching value. The output will look like this: Value 2 found at: (2,1) You can see from this example that using a label on a break statement in a nested loop, or not using the break statement at all, can cause the loop structure to behave quite differently.

Answer 33

the continue statement, a statement that causes flow to finish the execution of the current loop. You may notice the syntax of the continue statement mirrors that of the break statement. In fact, the statements are identical in how they are used, but with different results. While the break statement transfers control to the enclosing statement, the continue statement transfers control to the boolean expression that determines if the loop should continue. In other words, it ends the current iteration of the loop. Also, like the break statement, the continue statement is applied to the nearest inner loop under execution using optional label statements to override this behavior.

Answer 34

With the structure as defined, the loop will return control to the parent loop any time the first value is b or the second value is 2. On the first, third, and fourth executions of the outer loop, the inner loop prints a statement exactly once and then exits on the next inner loop when leopard is 2. On the second execution of the outer loop, the inner loop immediately exits without printing anything since b is encountered right away. The following is printed: ``` Cleaning: a,1 Cleaning: c,1 Cleaning: d,1 ``` Now, imagine we removed the CLEANING label in the continue statement so that control is returned to the inner loop instead of the outer. Line 6 becomes the following: `6: continue;` This corresponds to the zookeeper skipping all leopards except those labeled 2 or in stable b. The output would then be the following: ``` Cleaning: a,1 Cleaning: a,3 Cleaning: c,1 Cleaning: c,3 Cleaning: d,1 Cleaning: d,3 ``` Finally, if we remove the continue statement and associated if statement altogether by removing lines 5–7, we arrive at a structure that outputs all the values, such as this: ``` Cleaning: a,1 Cleaning: a,2 Cleaning: a,3 Cleaning: b,1 Cleaning: b,2 Cleaning: b,3 Cleaning: c,1 Cleaning: c,2 Cleaning: c,3 Cleaning: d,1 Cleaning: d,2 Cleaning: d,3 ```

Answer 35

creating methods and using return statements can be used as an alternative to using labels and break statements. ``` public class FindInMatrixUsingReturn { private static int[] searchForValue(int[][] list, int v) { for (int i = 0; i < list.length; i++) { for (int j = 0; j < list[i].length; j++) { if (list[i][j] == v) { return new int[] {i,j}; } } } return null; } public static void main(String[] args) { int[][] list = { { 1, 13 }, { 5, 2 }, { 2, 2 } }; int searchValue = 2; int[] results = searchForValue(list,searchValue); if (results == null) { System.out.println("Value " + searchValue + " not found"); } else { System.out.println("Value " + searchValue + " found at: " + "(" + results[0] + "," + results[1] + ")"); } } } ``` This class is functionally the same as the first FindInMatrix class we saw earlier using break. If you need finer-grained control of the loop with multiple break and continue statements, the first class is probably better. That said, we find code without labels and break statements a lot easier to read and debug. Also, making the search logic an independent function makes the code more reusable and the calling main() method a lot easier to read. For the exam, you will need to know both forms. Just remember that return statements can be used to exit loops quickly and can lead to more readable code in practice, especially when used with nested loops.

Answer 36

One facet of break, continue, and return that you should be aware of is that any code placed immediately after them in the same block is considered unreachable and will not compile. For example, the following code snippet does not compile: ``` int checkDate = 0; while(checkDate<10) { checkDate++; if(checkDate>100) { break; checkDate++; // DOES NOT COMPILE } } ``` Even though it is not logically possible for the if statement to evaluate to true in this code sample, the compiler notices that you have statements immediately following the break and will fail to compile with “unreachable code” as the reason.

Answer 37

the compiler notices that you have statements immediately following the break and will fail to compile with “unreachable code” as the reason. The same is true for continue and returnstatements too,

Answer 38

1. while - Allow optional labels - Allow break statement - Allow continue statement 2. do/while - Allow optional labels - Allow break statement - Allow continue statement 3. for - Allow optional labels - Allow break statement - Allow continue statement 4. switch - Allow optional labels - Allow break statement - Not allow continue statement

Answer 39

Understand if and else decision control statements. The if and else statements come up frequently throughout the exam in questions unrelated to decision control, so make sure you fully understand these basic building blocks of Java. Understand switch statements and their proper usage. You should be able to spot a poorly formed switch statement on the exam. The switch value and data type should be compatible with the case statements, and the values for the case statements must evaluate to compile-time constants. Finally, at runtime a switch statement branches to the first matching case, or default if there is no match, or exits entirely if there is no match and no default branch. The process then continues into any proceeding case or default statements until a break or return statement is reached. Understand while loops. Know the syntactical structure of all while and do/while loops. In particular, know when to use one versus the other. Be able to use for loops. You should be familiar with for and for-each loops and know how to write and evaluate them. Each loop has its own special properties and structures. You should know how to use for-each loops to iterate over lists and arrays. Understand how break, continue, and return can change flow control. Know how to change the flow control within a statement by applying a break, continue, or return statement. Also know which control statements can accept break statements and which can accept continue statements. Finally, you should understand how these statements work inside embedded loops or switch statements.

Answer 40

This chapter presented how to make intelligent decisions in Java. We covered basic decision-making constructs such as if, else, and switch statements and showed how to use them to change the path of process at runtime. Remember that the switch statement allows a lot of data types it did not in the past, such as String, enum, and in certain cases var. We then moved our discussion to repetition control structures, starting with while and do/while loops. We showed how to use them to create processes that looped multiple times and also showed how it is important to make sure they eventually terminate. Remember that most of these structures require the evaluation of a particular boolean expression to complete. Next, we covered the extremely convenient repetition control structures, for and for-each loops. While their syntax is more complex than the traditional while or do/while loops, they are extremely useful in everyday coding and allow you to create complex expressions in a single line of code. With a for-each loop you don’t need to explicitly write a boolean expression, since the compiler builds one for you. For clarity, we referred to an enhanced for loop as a for-each loop, but syntactically both are written using the for keyword. We concluded this chapter by discussing advanced control options and how flow can be enhanced through nested loops, coupled with break, continue, and return statements. Be wary of questions on the exam that use nested loops, especially ones with labels, and verify they are being used correctly. This chapter is especially important because at least one component of this chapter will likely appear in every exam question with sample code. Many of the questions on the exam focus on proper syntactic use of the structures, as they will be a large source of questions that end in “Does not compile.” You should be able to answer all of the review questions correctly or fully understand those that you answered incorrectly before moving on to later chapters.