View source for Book:ThinkJava/05 Conditionals and Logic

{{sidebar box|[[Book:ThinkJava|Table of contents]]}}


= Conditionals and Logic =

The programs we’ve seen in previous chapters do pretty much the same thing every time, regardless of the input. For more complex computations, programs usually react to inputs, check for certain conditions, and generate applicable results. This chapter introduces Java language features for expressing logic and making decisions.

== Relational Operators ==

Java has six <span>'''relational operators'''</span> that test the relationship between two values (e.g., whether they are equal, or whether one is greater than the other). The following expressions show how they are used:

<source lang="java">x == y          // x is equal to y
x != y          // x is not equal to y
x > y           // x is greater than y
x < y           // x is less than y
x >= y          // x is greater than or equal to y
x <= y          // x is less than or equal to y</source>
The result of a relational operator is one of two special values: <code>true</code> or <code>false</code>. These values belong to the data type <code>boolean</code>, named after the mathematician George Boole. He developed an algebraic way of representing logic.

You are probably familiar with these operators, but notice how Java is different from mathematical symbols like <math display="inline">=</math>, <math display="inline">\neq</math>, and <math display="inline">\geq</math>. A common error is to use a single <code>=</code> instead of a double <code>==</code> when comparing values. Remember that <code>=</code> is the <span>''assignment''</span> operator, and <code>==</code> is a <span>''relational''</span> operator. Also, the operators <code>=<</code> and <code>=></code> do not exist.

The two sides of a relational operator have to be compatible. For example, the expression <code>5 < "6"</code> is invalid because <code>5</code> is an <code>int</code> and <code>"6"</code> is a <code>String</code>. When comparing values of different numeric types, Java applies the same conversion rules we saw previously with the assignment operator. For example, when evaluating the expression <code>5 < 6.0</code>, Java automatically converts the <code>5</code> to <code>5.0</code>.

== The if-else Statement ==

To write useful programs, we almost always need to check conditions and react accordingly. <span>'''Conditional statements'''</span> give us this ability. The simplest conditional statement in Java is the <code>if</code> statement:

<source lang="java">if (x > 0) {
    System.out.println("x is positive");
}</source>
The expression in parentheses is called the condition. If it is true, the statements in braces get executed. If the condition is false, execution skips over that <span>'''block'''</span> of code. The condition in parentheses can be any <code>boolean</code> expression.

A second form of conditional statement has two possibilities, indicated by <code>if</code> and <code>else</code>. The possibilities are called <span>'''branches'''</span>, and the condition determines which branch gets executed:

<source lang="java">if (x % 2 == 0) {
    System.out.println("x is even");
} else {
    System.out.println("x is odd");
}</source>
If the remainder when <code>x</code> is divided by 2 is zero, we know that <code>x</code> is even, and the program displays a message to that effect. If the condition is false, the second print statement is executed instead. Since the condition must be true or false, exactly one of the branches will run.

The braces are optional for branches that have only one statement. So we could have written the previous example this way:

<source lang="java">if (x % 2 == 0)
    System.out.println("x is even");
else
    System.out.println("x is odd");</source>
However, it’s better to use braces—even when they are optional—to avoid making the mistake of adding statements to an <code>if</code> or <code>else</code> block and forgetting to add the braces. This code is misleading because it’s not indented correctly:

<source lang="java">if (x > 0)
    System.out.println("x is positive");
    System.out.println("x is not zero");</source>
Since there are no braces, only the first <code>println</code> is part of the <code>if</code> statement. Here is what the compiler actually sees:

<source lang="java">if (x > 0) {
    System.out.println("x is positive");
}
    System.out.println("x is not zero");</source>
As a result, the second <code>println</code> runs no matter what. Even experienced programmers make this mistake; search the web for Apple’s “goto fail” bug.

In all previous examples, notice how there is no semicolon at the end of the <code>if</code> or <code>else</code> lines. Instead, a new block should be defined using curly braces. Another common mistake is to put a semicolon after the condition, like this:

<source lang="java">int x = 1;
if (x % 2 == 0); {  // incorrect semicolon
    System.out.println("x is even");
}</source>
This code will compile, but the program will output <code>"x is even"</code> regardless what value <code>x</code> is. Here is the same incorrect code with better formatting:

<source lang="java">int x = 1;
if (x % 2 == 0)
    ;  // empty statement
{
    System.out.println("x is even");
}</source>
Because of the semicolon, the <code>if</code> statement compiles as if there are no braces, and the subsequent block runs independently. As a general rule, each line of Java code should end with a semicolon or brace—but not both.

The compiler won’t complain if you omit optional braces or write empty statements. Doing so is allowed by the Java language, but it often results in bugs that are difficult to find. Development tools like Checkstyle (see Appendix [[#checkstyle|[checkstyle]]]) can warn you about these and other kinds of programming mistakes.

== Chaining and Nesting ==

Sometimes you want to check related conditions and choose one of several actions. One way to do this is by <span>'''chaining'''</span> a series of <code>if</code> and <code>else</code> blocks:

<source lang="java">if (x > 0) {
    System.out.println("x is positive");
} else if (x < 0) {
    System.out.println("x is negative");
} else {
    System.out.println("x is zero");
}</source>
These chains can be as long as you want, although they can be difficult to read if they get out of hand. One way to make them easier to read is to use standard indentation, as demonstrated in these examples. If you keep all the statements and braces lined up, you are less likely to make syntax errors.

Notice that the last branch is simply <code>else</code>, not <code>else if (x == 0)</code>. At this point in the chain, we know that <code>x</code> is not positive and <code>x</code> is not negative. There is no need to test whether <code>x</code> is zero, because there is no other possibility.

In addition to chaining, you can also make complex decisions by <span>'''nesting'''</span> one conditional statement inside another. We could have written the previous example as:

<source lang="java">if (x > 0) {
    System.out.println("x is positive");
} else {
    if (x < 0) {
        System.out.println("x is negative");
    } else {
        System.out.println("x is zero");
    }
}</source>
The outer conditional has two branches. The first branch contains a <code>print</code> statement, and the second branch contains another conditional statement, which has two branches of its own. These two branches are also <code>print</code> statements, but they could have been conditional statements as well.

These kinds of nested structures are common, but they can become difficult to read very quickly. Good indentation is essential to make the structure (or intended structure) apparent to the reader.

== The switch Statement ==

If you need to make a series of decisions, chaining <code>else if</code> blocks can get long and redundant. For example, consider a program that converts integers like <code>1</code>, <code>2</code>, and <code>3</code> into words like <code>"one"</code>, <code>"two"</code>, and <code>"three"</code>:

<source lang="java">if (number == 1) {
    word = "one";
} else if (number == 2) {
    word = "two";
} else if (number == 3) {
    word = "three";
} else {
    word = "unknown";
}</source>
This chain could go on and on, especially for banking programs that write numbers in long form (e.g., “one hundred twenty-three and 45/100 dollars”). An alternative way to evaluate many possible values of an expression is to use a <code>switch</code> statement:

<source lang="java">switch (number) {
    case 1:
        word = "one";
        break;
    case 2:
        word = "two";
        break;
    case 3:
        word = "three";
        break;
    default:
        word = "unknown";
        break;
}</source>
The body of a <code>switch</code> statement is organized into one or more <code>case</code> blocks. Each <code>case</code> ends with a <code>break</code> statement, which exits the <code>switch</code> body. The <code>default</code> block is optional and executed only if none of the cases apply.

Although <code>switch</code> statements appear longer than chained <code>else if</code> blocks, they are particularly useful when multiple cases can be grouped:

<source lang="java">switch (food) {
    case "apple":
    case "banana":
    case "cherry":
        System.out.println("Fruit!");
        break;
    case "asparagus":
    case "broccoli":
    case "carrot":
        System.out.println("Vegetable!");
        break;
}</source>
== Logical Operators ==

In addition to the relational operators, Java also has three <span>'''logical operators'''</span>: <code>&amp;&amp;</code>, <code>||</code>, and <code>!</code>, which respectively stand for <span>''and''</span>, <span>''or''</span>, and <span>''not''</span>. The results of these operators are similar to their meanings in English.

For example, <code>x > 0 &amp;&amp; x < 10</code> is true when <code>x</code> is both greater than zero <span>''and''</span> less than 10.

The expression <code>x < 0 || x > 10</code> is true if either condition is true, that is, if <code>x</code> is less than 0 <span>''or''</span> greater than 10.

Finally, <code>!(x > 0)</code> is true if <code>x</code> is <span>''not''</span> greater than 0. The parentheses are necessary in this example because in the order of operations <code>!</code> comes before <code>></code>.

In order for an expression with <code>&amp;&amp;</code> to be true, both sides of the <code>&amp;&amp;</code> operator must be true. And in order for an expression with <code>||</code> to be false, both sides of the <code>||</code> operator must be false.

The <code>&amp;&amp;</code> operator can be used to simplify nested <code>if</code> statements. For example, following code can be rewritten with a single condition.

<source lang="java">if (x == 0) {
    if (y == 0) {
        System.out.println("Both x and y are zero");
    }
}</source>
<source lang="java">// combined
if (x == 0 &amp;&amp; y == 0) {
    System.out.println("Both x and y are zero");
}</source>
Likewise, the <code>||</code> operator can simplify chained <code>if</code> statements. Since the branches are the same, there is no need to duplicate that code.

<source lang="java">if (x == 0) {
    System.out.println("Either x or y is zero");
} else if (y == 0) {
    System.out.println("Either x or y is zero");
}</source>
<source lang="java">// combined
if (x == 0 || y == 0) {
    System.out.println("Either x or y is zero");
}</source>
Then again, if the statements in the branches were different, we could not combine them into one block. But it’s useful to explore different ways of representing the same logic, especially when it’s complex.

<span id="shortcircuit" label="shortcircuit">[shortcircuit]</span>

Logical operators evaluate the second expression only when necessary. For example, <code>true || anything</code> is always true, so Java does not need to evaluate the expression <code>anything</code>. Likewise, <code>false &amp;&amp; anything</code> is always false.

Ignoring the second operand, when possible, is called <span>'''short circuit'''</span> evaluation, by analogy with an electrical circuit. Short circuit evaluation can save time, especially if <code>anything</code> takes a long time to evaluate. It can also avoid unnecessary errors, if <code>anything</code> might fail.

== De Morgan’s Laws ==

Sometimes you need to negate an expression containing a mix of relational and logical operators. For example, to test if <code>x</code> and <code>y</code> are both nonzero, you could write:

<source lang="java">if (!(x == 0 || y == 0)) {
    System.out.println("Neither x nor y is zero");
}</source>
This condition is difficult to read because of the <code>!</code> and parentheses. A better way to negate logic expressions is to apply <span>'''De Morgan’s laws'''</span>:

* <code>!(A &amp;&amp; B)</code>  is the same as  <code>!A || !B</code>
* <code>!(A || B)</code>  is the same as  <code>!A &amp;&amp; !B</code>

In words, negating a logical expression is the same as negating each term and changing the operator. The <code>!</code> operator takes precedence over <code>&amp;&amp;</code> and <code>||</code>, so you don’t have to put parentheses around the individual terms <code>!A</code> and <code>!B</code>.

De Morgan’s laws also apply to the relational operators. In this case, negating each term means using the “opposite” relational operator.

* <code>!(x < 5 &amp;&amp; y == 3)</code>  is the same as  <code>x >= 5 || y != 3</code>
* <code>!(x >= 1 || y != 7)</code>  is the same as  <code>x < 1 &amp;&amp; y == 7</code>

It may help to read these examples out loud in English. For instance, “If I don’t want the case where <math display="inline">x</math> is less than 5 and <math display="inline">y</math> is 3, then I need <math display="inline">x</math> to be greater than or equal to 5, or I need <math display="inline">y</math> to be anything but 3.”

Returning to the previous example, here is the revised condition. In English, it reads “if <math display="inline">x</math> is not zero and <math display="inline">y</math> is not zero.” The logic is the same, and the source code is easier to read.

<source lang="java">if (x != 0 &amp;&amp; y != 0) {
    System.out.println("Neither x nor y is zero");
}</source>
== Boolean Variables ==

To store a <code>true</code> or <code>false</code> value, you need a <code>boolean</code> variable. You can declare and assign them like other variables. In this example, the first line is a variable declaration, the second is an assignment, and the third is both:

<source lang="java">boolean flag;
flag = true;
boolean testResult = false;</source>
Since relational and logical operators evaluate to a <code>boolean</code> value, you can store the result of a comparison in a variable:

<source lang="java">boolean evenFlag = (n % 2 == 0);    // true if n is even
boolean positiveFlag = (x > 0);     // true if x is positive</source>
The parentheses are unnecessary, but they make the code easier to understand. A variable defined in this way is called a <span>'''flag'''</span>, because it signals or “flags” the presence or absence of a condition.

You can use flag variables as part of a conditional statement:

<source lang="java">if (evenFlag) {
    System.out.println("n was even when I checked it");
}</source>
Flags may not seem that useful at this point, but they will help simplify complex conditions later on. Each part of a condition can be stored in a separate flag, and these flags can be combined with logical operators.

Notice that we didn’t have to write  <code>if (evenFlag == true)</code>. Since <code>evenFlag</code> is a <code>boolean</code>, it’s already a condition. To check if a flag is <code>false</code>, we simply negate the flag:

<source lang="java">if (!evenFlag) {
    System.out.println("n was odd when I checked it");
}</source>
In general, you should never compare anything to true or false. Doing so makes the code more verbose and awkward to read out loud.

== Boolean Methods ==

Methods can return <code>boolean</code> values, just like any other type, which is often convenient for hiding tests inside methods. For example:

<source lang="java">public static boolean isSingleDigit(int x) {
    if (x > -10 &amp;&amp; x < 10) {
        return true;
    } else {
        return false;
    }
}</source>
The name of this method is <code>isSingleDigit</code>. It is common to give <code>boolean</code> methods names that sound like yes/no questions. Since the return type is <code>boolean</code>, the return statement has to provide a boolean expression.

The code itself is straightforward, although it is longer than it needs to be. Remember that the expression <code>x > -10 &amp;&amp; x < 10</code> has type <code>boolean</code>, so there is nothing wrong with returning it directly (without the <code>if</code> statement):

<source lang="java">public static boolean isSingleDigit(int x) {
    return x > -10 &amp;&amp; x < 10;
}</source>
In <code>main</code>, you can invoke the method in the usual ways:

<source lang="java">System.out.println(isSingleDigit(2));
boolean bigFlag = !isSingleDigit(17);</source>
The first line displays <span>true</span> because 2 is a single-digit number. The second line sets <code>bigFlag</code> to <code>true</code>, because 17 is <span>''not''</span> a single-digit number.

Conditional statements often invoke <code>boolean</code> methods and use the result as the condition:

<source lang="java">if (isSingleDigit(z)) {
    System.out.println("z is small");
} else {
    System.out.println("z is big");
}</source>
Examples like this one almost read like English: “If is single digit z, print z is small else print z is big.”

== Validating Input ==

One of the most important tasks in any computer program is to <span>'''validate'''</span> input from the user. People often make mistakes while typing, especially on smartphones, and incorrect inputs may cause your program to fail.

Even worse, someone (i.e., a <span>'''hacker'''</span>) may intentionally try to break into your system by entering unexpected inputs. You should never assume that users will input the right kind of data.

Consider this simple program that prompts the user for a number and computes its logarithm:

<source lang="java">Scanner in = new Scanner(System.in);
System.out.print("Enter a number: ");
double x = in.nextDouble();
double y = Math.log(x);
System.out.println("The log is " + y);</source>
In mathematics, the natural logarithm (base <math display="inline">e</math>) is undefined when <math display="inline">x \le 0</math>. In Java, if you ask for <code>Math.log(-1)</code>, it returns <span>'''NaN'''</span>, which stands for “not a number”. We can check for this condition and print an appropriate message:

<source lang="java">if (x > 0) {
    double y = Math.log(x);
    System.out.println("The log is " + y);
} else {
    System.out.println("The log is undefined");
}</source>
The output is better now, but there is another problem. What if the user doesn’t enter a number at all? What would happen if they typed the word “hello”, either on accident or on purpose?

<source lang="java">Exception in thread "main" java.util.InputMismatchException
    at java.util.Scanner.throwFor(Scanner.java:864)
    at java.util.Scanner.next(Scanner.java:1485)
    at java.util.Scanner.nextDouble(Scanner.java:2413)
    at Logarithm.main(Logarithm.java:8)</source>
If the user inputs a <code>String</code> when we expect a <code>double</code>, Java reports an “input mismatch” exception. We can prevent this run-time error from happening by testing the input first.

The <code>Scanner</code> class provides <code>hasNextDouble</code>, which checks whether the next input can be interpreted as a <code>double</code>. If not, we can display an error message.

<source lang="java">if (!in.hasNextDouble()) {
    String word = in.next();
    System.err.println(word + "is not a number");
}</source>
In contrast to <code>in.nextLine</code>, which returns an entire line of input, the <code>in.next</code> method returns only the next token of input. We can use <code>in.next</code> to show the user exactly which word they typed was not a number.

This example also uses <code>System.err</code>, which is an <code>OutputStream</code> for error messages and warnings. Some development environments display output to <code>System.err</code> with a different color or in a separate window.

== Example Program ==

In this chapter we have seen relational and logical operators, <code>if</code> statements, boolean methods, and validating input. The following program shows how the individual code examples in the previous section fit together.

<source lang="java">{Logarithm.java}
import java.util.Scanner;

/**
 * Demonstrates input validation using if statements.
 */
public class Logarithm {

    public static void main(String[] args) {

        // prompt for input
        Scanner in = new Scanner(System.in);
        System.out.print("Enter a number: ");

        // check the format
        if (!in.hasNextDouble()) {
            String word = in.next();
            System.err.println(word + " is not a number");
            return;
        }

        // check the range
        double x = in.nextDouble();
        if (x > 0) {
            double y = Math.log(x);
            System.out.println("The log is " + y);
        } else {
            System.out.println("The log is undefined");
        }
    }
}</source>
Notice how the <code>return</code> statement allows you to exit a method before you reach the end of it. Returning from <code>main</code> terminates the program.

What started as five lines of code at the beginning of Section [[#validate|1.9]] is now a 30-line program. Making programs robust (and secure) often requires a lot of additional checking, as shown in this example.

It’s important to write comments every few lines to make your code easier to understand. Comments not only help other people read your code, they also help you document what you’re trying to do. If there’s a mistake the code, it’s a lot easier to find when there are good comments.

== Vocabulary ==

A data type with only two possible values, <code>true</code> and <code>false</code>.

An operator that compares two values and produces a <code>boolean</code> indicating the relationship between them.

A statement that uses a condition to determine which statements to execute.

A sequence of statements, surrounded by braces, that generally runs as the result of a condition.

One of the alternative blocks after a conditional statement. For example, an <code>if</code>-<code>else</code> statement has two branches.

A way of joining several conditional statements in sequence.

Putting a conditional statement inside one or both branches of another conditional statement.

An operator that combines boolean values and produces a boolean value.

A way of evaluating logical operators that only evaluates the second operand if necessary.

Mathematical rules that show how to negate a logical expression.

A variable (usually <code>boolean</code>) that represents a condition or status.

To confirm that an input value is of the correct type and within the expected range.

A programmer who breaks into computer systems. The term hacker may also apply to someone who enjoys writing code.

A special floating-point value that stands for “not a number”.

== Exercises ==

The code for this chapter is in the <span>ch05</span> directory of <span>ThinkJavaCode2</span>. See page  for instructions on how to download the repository. Before you start the exercises, we recommend that you compile and run the examples.

If you have not already read Appendix [[#checkstyle|[checkstyle]]], now might be a good time. It describes Checkstyle, a tool that analyzes many aspects of your source code.

Rewrite the following code using a single <code>if</code> statement.

<source lang="java">if (x > 0) {
    if (x < 10) {
        System.out.println("positive single digit number.");
    }
}</source>
Now that we have conditional statements, we can get back to the “Guess My Number” game from Exercise [[#guess|[guess]]].

You should already have a program that chooses a random number, prompts the user to guess it, and displays the difference between the guess and the chosen number.

Adding a small amount of code at a time, and testing as you go, modify the program so it tells the user whether the guess is too high or too low, and then prompts the user for another guess.

The program should continue until the user gets it right or guesses incorrectly three times. If the user guesses the correct number, display a message and terminate the program.

Fermat’s Last Theorem says that there are no integers <math display="inline">a</math>, <math display="inline">b</math>, <math display="inline">c</math>, and <math display="inline">n</math> such that <math display="inline">a^n + b^n = c^n</math>, except when <math display="inline">n \leq 2</math>.

Write a program named <code>Fermat.java</code> that inputs four integers (<code>a</code>, <code>b</code>, <code>c</code>, and <code>n</code>) and checks to see if Fermat’s theorem holds. If <math display="inline">n</math> is greater than 2 and <math display="inline">a^n + b^n = c^n</math>, the program should display “Holy smokes, Fermat was wrong!” Otherwise the program should display “No, that doesn’t work.”

<span>''Hint:''</span> You might want to use <code>Math.pow</code>.

Using the following variables, evaluate the logic expressions in the table below. Write your answers as true, false, or error.

<source lang="java">boolean yes = true;
boolean no = false;
int loVal = -999;
int hiVal = 999;
double grade = 87.5;
double amount = 50.0;
String hello = "world";</source>
<span>|l|l|</span> Expression &amp; Result<br />
<code>yes == no || grade > amount</code> &amp;<br />
<code>amount == 40.0 || 50.0</code> &amp;<br />
<code>hiVal != loVal || loVal < 0</code> &amp;<br />
<code>True || hello.length() > 0</code> &amp;<br />
<code>hello.isEmpty() &amp;&amp; yes</code> &amp;<br />
<code>grade <= 100 &amp;&amp; !false</code> &amp;<br />
<code>!yes || no</code> &amp;<br />
<code>grade > 75 > amount</code> &amp;<br />
<code>amount <= hiVal &amp;&amp; amount >= loVal</code> &amp;<br />
<code>no &amp;&amp; !no || yes &amp;&amp; !yes</code> &amp;<br />


What is the output of the following program? Determine the answer without using a computer.

<source lang="java">public static void main(String[] args) {
    boolean flag1 = isHoopy(202);
    boolean flag2 = isFrabjuous(202);
    System.out.println(flag1);
    System.out.println(flag2);
    if (flag1 &amp;&amp; flag2) {
        System.out.println("ping!");
    }
    if (flag1 || flag2) {
        System.out.println("pong!");
    }
}</source>
<source lang="java">public static boolean isHoopy(int x) {
    boolean hoopyFlag;
    if (x % 2 == 0) {
        hoopyFlag = true;
    } else {
        hoopyFlag = false;
    }
    return hoopyFlag;
}</source>
<source lang="java">public static boolean isFrabjuous(int x) {
    boolean frabjuousFlag;
    if (x > 0) {
        frabjuousFlag = true;
    } else {
        frabjuousFlag = false;
    }
    return frabjuousFlag;
}</source>
The purpose of this exercise is to make sure you understand logical operators and the flow of execution through methods.

Write a program named <code>Quadratic.java</code> that finds the roots of <math display="inline">ax^2 + bx + c = 0</math> using the quadratic formula: <math display="block">x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}</math> Prompt the user to input integers for <math display="inline">a</math>, <math display="inline">b</math>, and <math display="inline">c</math>. Compute the two solutions for <math display="inline">x</math>, and display the results.

Your program should be able to handle inputs for which there is only one or no solution. Specifically, it should not divide by zero or take the square root of a negative number.

Be sure to validate all inputs. The user should never see an input mismatch exception. Display specific error messages that include the invalid input.

If you are given three sticks, you may or may not be able to arrange them in a triangle. For example, if one of the sticks is 12 inches long and the other two are one inch long, you will not be able to get the short sticks to meet in the middle. For any three lengths, there is a simple test to see if it is possible to form a triangle:

<blockquote>If any of the three lengths is greater than the sum of the other two, you cannot form a triangle.
</blockquote>
Write a program named <code>Triangle.java</code> that inputs three integers, and then outputs whether you can (or cannot) form a triangle from the given lengths. Reuse your code from the previous exercise to validate the inputs. Display an error if any of the lengths are negative or zero.