Decision structures: if/else, logical operators, switch

Until now the program ran every line from top to bottom. Decision structures (selection statements) let you run some lines and skip others depending on a condition. Two kinds of questions come up on the midterm: following the conditions to find what is printed, and writing short methods that say “return this for that value” (letter grade, month name, season).

Golden rules:

1. In an else if chain the first true branch runs, and the rest are not looked at.
2. Without curly braces an if covers a single statement. Indentation misleads.
3. && and || short-circuit: once the result is known, the right side does not run at all.
4. In a switch, without break it falls through (fall-through), default included.
5. = is assignment, == is comparison. = inside an if does not compile.

Comparison and boolean expressions

Relational operators compare two values and produce a boolean (true/false).

int a = 7, b = 3;
System.out.println((a > b) + " " + (a == b) + " " + (a != b) + " " + (a <= 7));
boolean big = a > 5;
System.out.println(big);

true false true true
true

A boolean can be stored in a variable and printed directly.

PITFALL · a single equals sign inside an if. if (x = 5) does not compile: incompatible types: int cannot be converted to boolean. An if wants a boolean, and x = 5 is an assignment that produces an int.

if and if-else

int temp = 12;
if (temp > 25) {
    System.out.println("Sicak");
} else {
    System.out.println("Serin");
}
System.out.println("Bitti");

Serin
Bitti

If the condition is true, the if block runs; if it is false, the else block runs. Exactly one of the two runs. The lines after the block (Bitti) run in every case.

The else if chain

When there are several ranges, you use else if. Java tries the conditions from top to bottom, runs the first true one, and skips the rest of the chain.

public static String letter(int score) {
    if (score >= 90) return "A";
    else if (score >= 80) return "B";
    else if (score >= 70) return "C";
    else if (score >= 60) return "D";
    else return "F";
}

Calls letter(85), letter(90), letter(59):

B A F

When we reach the score >= 80 branch for 85, we already know score < 90; so there is no need to write score >= 80 && score < 90.

PITFALL · wrong order. If you start the chain from the small end, like if (score >= 60) return "D"; else if (score >= 70) ..., even a student with 95 gets a D, because the first true condition is >= 60. During verification letterWrongOrder(95) really returned D. When you work with lower bounds, order them from largest to smallest.

A chain and separate ifs are different:

int s = 95;
if (s >= 90) System.out.print("A ");
if (s >= 80) System.out.print("B ");
if (s >= 70) System.out.print("C ");

A B C 

Three separate ifs, all three are checked independently and all three are true.

Curly brace and semicolon traps

int x = -2, cnt = 0, other = 0;
if (x > 0)
    cnt++;
    other++;          // the indentation misleads: this line is OUTSIDE the if
System.out.println(cnt + " " + other);
int y = -5;
if (y > 0);           // the ; at the end is an empty statement, it is the if's body
{
    System.out.println("pozitif?");
}

0 1
pozitif?

In the second example the body of the if is that empty semicolon. The curly brace block below has nothing to do with the if and always runs. pozitif? was printed even though y is negative.

Dangling else

int m = 5, n = 20;
if (m > 10)
    if (n > 10)
        System.out.println("ikisi de buyuk");
else
    System.out.println("else kime ait?");
System.out.println("son");

son

An else always belongs to the nearest unmatched if: here the inner if (n > 10). The indentation makes it look as if it belonged to the outer if, but Java does not look at indentation. Because the outer condition is false, nothing inside ran. The way to avoid this: always use { }.

Logical operators

Precedence: first !, then &&, last ||. Comparisons are done before these, which is why age >= 18 && student works without parentheses.

int age = 20;
boolean student = true;
System.out.println(age >= 18 && student);
System.out.println(age < 18 || !student);
System.out.println(!(age == 20));
System.out.println(true || false && false);     // && first: true || false
System.out.println((true || false) && false);

true
false
false
true
false

Short-circuit evaluation

• &&: if the left side is false, the result is already false, and the right side is not looked at.
• ||: if the left side is true, the result is already true, and the right side is not looked at.

This is used as a guard:

int d = 0;
if (d != 0 && 10 / d > 1) System.out.println("buyuk");
else System.out.println("guvenli");

guvenli

Because d != 0 is false, 10 / d was never computed and the program did not crash. If you had written the order the other way round (10 / d > 1 && d != 0) you would get an ArithmeticException.

If the right side has a side effect like ++z, short-circuiting means that side effect never happens. The midterm sets exactly this trap.

The conditional operator (ternary)

condition ? value1 : value2 is a short if-else; it produces a value.

int t1 = 8;
String parity = (t1 % 2 == 0) ? "even" : "odd";
System.out.println(parity);

even

switch

You use switch to branch on specific values of a variable. It works with int, char, String (and byte, short); it cannot be written with double or boolean.

int day = 3;
switch (day) {
    case 1: System.out.println("Mon"); break;
    case 2: System.out.println("Tue"); break;
    case 3: System.out.println("Wed"); break;
    default: System.out.println("Other");
}

Wed

The rule: Java jumps to the matching case, starts running downward from there, and continues until it sees a break. If no case matches, default runs (like else). default is not required.

Fall-through

int lvl = 2;
switch (lvl) {
    case 1: System.out.println("one");
    case 2: System.out.println("two");
    case 3: System.out.println("three");
    default: System.out.println("default");
}

two
three
default

It entered at case 2, and because there was no break, everything below ran, default included. case 1 stayed above, so it did not run: a switch never goes above the matching case.

Fall-through is also used on purpose: if several values do the same job, you write the cases one under another.

char g = 'B';
switch (g) {
    case 'A': case 'B': System.out.println("Iyi"); break;
    case 'C': System.out.println("Orta"); break;
    default: System.out.println("Zayif");
}
String cmd = "stop";
switch (cmd) {
    case "go": System.out.println("Gidiyor"); break;
    case "stop": System.out.println("Duruyor"); break;
    default: System.out.println("?");
}

Iyi
Duruyor

switch inside a method: with return

If the method returns a value, you write return in every case. Because return ends the method immediately, no break is needed. daysInMonth in the question bank above is an example of this pattern; the season, day name and letter grade questions are solved with the same skeleton.

Common mistakes

int x = 15;
if (x > 10) System.out.println("A");
else if (x > 5) System.out.println("B");
else System.out.println("C");

int x = 15;
if (x > 10) System.out.print("A");
if (x > 5) System.out.print("B");
else System.out.print("C");
System.out.println();

int a = 4, b = 9;
System.out.println(a > 3 && b < 5);
System.out.println(a > 3 || b < 5);
System.out.println(!(a > 3) || b % 3 == 0);

int x = 0;
if (x > 0)
    System.out.println("pos");
    System.out.println("checked");

switch (day) {
    case 1: System.out.println("Red");
    case 2: System.out.println("Green");
    case 3: System.out.println("Blue"); break;
    case 4: System.out.println("Black");
    default: System.out.println("White");
}

int q = 3, z = 0;
if (q > 5 && ++z > 0) System.out.println("in");
System.out.println(z);
if (q < 5 || ++z > 0) System.out.println("in2");
System.out.println(z);

int a = 2, b = 8;
if (a > 5)
    if (b > 5)
        System.out.println("X");
else
    System.out.println("Y");
System.out.println("Z");

int n = 7;
String res = (n > 5) ? (n > 10 ? "big" : "medium") : "small";
System.out.println(res);

String w = "B";
switch (w) {
    case "A": System.out.print("1 ");
    case "B": System.out.print("2 ");
    case "C": System.out.print("3 "); break;
    default: System.out.print("4 ");
}

int score = 72;
if (score >= 90) System.out.println("A");
if (score >= 70) System.out.println("C");
else if (score >= 60) System.out.println("D");
else System.out.println("F");