Construction. if statements

[comp1110-0F]
  • Liam O'Connor

Conditionals are a way for control flow to branch — based on a certain condition, we will either execute one branch of code or another. The most common conditional in Java is the if statement.

if (condition) { IO.println("condition is true!"); } else { IO.println("condition is false!"); }

The else branch in the above code sketch is optional.

Context

    Starting with Java

    [comp1110-0K]
    • July 30, 2026
    • Liam O'Connor, Fabian Muehlboeck

    Example. A Java Greeter

    [comp1110-0C]
    • July 30, 2026
    • Liam O'Connor, Fabian Muehlboeck

    In the lecture we created a source code file called Main.java, but rather than the boring Hello World! message that is so common in programming tutorials, we opted for a more apt message:

    void main() { IO.println("I am not sentient."); }

    This code defines a function, called main, which takes no parameters as inputs and returns nothing (void) as outputs. The function doesn't produce any output because it instead relies on side-effects to perform its function. The function IO.println() will, given a value of type String, display that value on the terminal, followed by a newline. Each statement in a function body must be terminated by a semicolon ;.

    To try our program out, we must compile it with the javac command, which will produce a matching .class file — these files are in a binary format that the Java Virtual Machine can execute. Then, we use java to run it:

    $ javac Main.java $ ls Main.class Main.java $ java Main I am not sentient. $

    Example. Reading Input

    [comp1110-0E]
    • July 30, 2026
    • Liam O'Connor, Fabian Muehlboeck

    Suppose we want to read some input from the user. The function IO.readln() (optionally) takes a prompt to give to the user and returns one line of input that the user typed on their console. Like so:

    IO.readln("Am I sentient?");

    If we don't simply want to ignore whatever the user writes as an answer, we need to create a variable to store the user's input in. In Java, all variables have types. The type of the user's input is a String, so we'll declare a variable called answer and use it to store the user's input. Extending our Java greeter:

    void main() { String answer = IO.readln("Am I sentient?"); IO.println("Your answer was " + answer); }

    This example demonstrates two new concepts: assignment using the = operator, and concatenation with the + operator.

    In Java, when we write:

    answer = "Hello";

    It should not be understood as a "defining equation" or a mathematical definition of the variable answer. That is because (unlike in, say, Haskell, where variables are unchanging) the value of a variable in Java can change as the program executes. This is called mutability. Instead, the above line of code should be understood to mean "replace whatever value is in the answer variable with the "Hello" string".

    $ javac Main.java $ java Main Am I sentient?no Your answer was no $

    Construction. if statements

    [comp1110-0F]
    • Liam O'Connor

    Conditionals are a way for control flow to branch — based on a certain condition, we will either execute one branch of code or another. The most common conditional in Java is the if statement.

    if (condition) { IO.println("condition is true!"); } else { IO.println("condition is false!"); }

    The else branch in the above code sketch is optional.

    Example. Branching based on user input

    [comp1110-0G]
    • July 30, 2026
    • Liam O'Connor, Fabian Muehlboeck

    Further extending our Reading Input example:

    void main() { String answer = IO.readln("Am I sentient?"); if (answer.equals("yes")) { IO.println("No, you are wrong!"); } else if (answer.equals("no")) { IO.println("You are right."); } else { IO.println("I don't understand you."); } IO.println("I am not sentient."); }

    Try this program out on a few inputs. Here we can see chaining of multiple if statements using else if. We can also see that the program keeps executing after the if statement concludes.

    Warning. String comparisons

    [comp1110-0H]
    • July 30, 2026
    • Liam O'Connor, Fabian Muehlboeck

    If you are familiar with other programming languages, you might be wondering why we compared strings in Example [comp1110-0G] using a.equals(b) instead of something like a == b. While a == b is indeed the normal way to compare (e.g.) numbers, in Java equality for Strings is a little more complicated. In Example [comp1110-0G], a comparison answer == "yes" would always fail, even if the contents of answer were identical to the contents of the string "yes", because the two strings themselves have different identities, and exist at different locations in memory. Using the notation answer.equals("yes") instead compares the contents of the strings rather than their location, which is usually the functionality that we want.

    Note. Case conversion

    [comp1110-0I]
    • July 30, 2026
    • Liam O'Connor, Fabian Muehlboeck

    You may notice that Example [comp1110-0G] is sensitive to the case of the input string. We can change this by converting the string answer to lower case before our if statement executes, by adding this line:

    answer = answer.toLowerCase();

    or by replacing occurrences of answer with answer.toLowerCase(). In Java, there are lots of things you can do with Strings. Consult the Java API Documentation for Strings to see all String methods.

    Backlinks

      Example. Branching based on user input

      [comp1110-0G]
      • July 30, 2026
      • Liam O'Connor, Fabian Muehlboeck

      Further extending our Reading Input example:

      void main() { String answer = IO.readln("Am I sentient?"); if (answer.equals("yes")) { IO.println("No, you are wrong!"); } else if (answer.equals("no")) { IO.println("You are right."); } else { IO.println("I don't understand you."); } IO.println("I am not sentient."); }

      Try this program out on a few inputs. Here we can see chaining of multiple if statements using else if. We can also see that the program keeps executing after the if statement concludes.

      Warning. A common anti-pattern

      [comp1110-0T]
      • Liam O'Connor

      It's common for beginner programmers to use (sometimes multiple) if statements to achieve what can be achieved by simple boolean operators instead. For example, the following code can be greatly simplified:

      if (a) { if (b) { return true; } else { return false; } } else { return false; }

      Firstly, we can combine the if statements into one using boolean conjunction:

      if (a && b) { return true; } else { return false; }

      And, because we are simply returning the same value as the result of that boolean check a && b, we can elide the if statement completely:

      return (a && b);

      Note. Omitting braces

      [comp1110-1G]
      • Liam O'Connor

      For for and while loops, as well as if statements, the braces may be omitted if the body consists of just one statement. For example, the body of contains (Example [comp1110-1A] and Example [comp1110-16]) can be rewritten as follows:

      for (int i = 0; i < haystack.length; i++) if (haystack[i] == needle) return true;

      However, this abbreviation can be a danger, because minor syntax errors can lead to unexpected behaviour. For example:

      for (int i = 0; i < haystack.length; i++) if (haystack[i] == needle) IO.println("Found it!") return true;

      This appears correct, but that's only because of indentation (which Java ignores). So this code is actually equivalent to:

      for (int i = 0; i < haystack.length; i++) if (haystack[i] == needle) IO.println("Found it!") return true;

      Quite a different program indeed!

      Definition. The boolean type

      [comp1110-0P]
      • Liam O'Connor

      The type boolean is for values that may be either true or false. We can combine boolean values with the conjunction (&&) and disjunction (||) operators. The expression a && b is true exactly when both a and b are true. The expression a || b is true if at least one of a or b is true. We can also negate boolean values with the negation (!) operator. The guards of if statements and while loops are always expressions of type boolean.

      Construction. The switch expression on enums

      [comp1110-76]
      • Liam O'Connor, Fabian Muehlboeck

      switch is a control structure, like if and while. In contrast to these two, however, switch can also be used as an expression form, which means it can be used as the right-hand side of an assignment. For example:

      int daysInMonth(Month m, boolean isLeapYear) { int days = switch (m) { case JANUARY -> 31; case FEBRUARY -> { if (isLeapYear) { yield 29; } else { yield 28; } } case MARCH -> 31; case APRIL -> 30; case MAY -> 31; case JUNE -> 30; case JULY -> 31; case AUGUST -> 31; case SEPTEMBER -> 30; case OCTOBER -> 31; case NOVEMBER -> 30; case DECEMBER -> 31; }; // Note the semicolon here return days; }

      In this case, it is important that each case of the switch expression returns a value of a suitable type. If you need more complicated logic for a case, you can have a code block enclosed in curly braces, where the special yield statement works like a sort of local return statement.

      This form is not really important for this course, but you may encounter it in newer Java code.

      Construction. Try-Catch-Finally

      [comp1110-90]
      • Fabian Muehlboeck

      Like if, while, and switch, try-catch-finally is a control flow construct, written as follows:

      try { // a bunch of statements that form // the normal path of execution } catch(TypeOfException e) { // if any code inside the try-block // throws an object of type // TypeOfException, AND no nested // try-block inside the try-block // caught it, then we immediately // abort execution the code in the // try-block and instead continue // in here } catch(AnotherTypeOfException e) { // same as above, but for a // different class of exceptions } finally { // regardless of whether the // try-block finished normally // or threw an exception, and // in the second case, regardless // of whether that exception was // caught here or not, the code // in here will be executed before // we leave the overall construct }

      You can generally have arbitrarily many catch-blocks after a try-block, and at most one finally-block. There must be at least one catch-block or a finally-block after a try-block.

      bars magnifying-glass caret-down plus minus arrow-right xmark