The boolean type is derived from the work of British mathematician George Boole, who in the 1850s, developed an algebra to process logical expressions such as p and q. Such boolean expressions produce a value that is either true or false. Every modern programming language provides some means of representing boolean expressions.
The boolean type has several important uses. As we saw in Chapter 1, expressions of the form num == 7 and 5 < 7 have boolean values. Similarly, as we saw in Chapter 3, the boolean type is also used to represent the condition in the if statement:
For this reason, boolean expressions are also called conditions. Along these same lines, a boolean variable can be used as a flag or a signal to “remember” whether or not a certain condition holds. For example, in the following code fragment, we use isDone to mark when a particular process is completed:
boolean isDone =false;// Initialize the flag...// Do some processing task
isDone =true;// Set flag when the task done...// Do some other stuffif(isDone)// Check if finished the task...// If so, do somethingelse...// Or, do something else
Subsection5.2.1Boolean (or Logical) Operations
Like all the other simple data types, the boolean type consists of certain data— the values true and false — and certain actions or operations that can be performed on those data. There are four basic boolean operations:
Try running the code below to see the boolean operator or (||) in action. Change the values of the two boolean variables to figure when the or-expression is true.
A truth table defines boolean operators by giving their values in all possible situations. The first two columns of the table give possible boolean values for two operands,o1 and o2. An operand is a value used in an operation. Note that each row gives a different value assignment to the two operands, so that all possible assignments are represented. The remaining columns give the values that result for the various operators given the assignment of values to o1 and o2.
To see how to read this table, let’s look at the AND operation, which is defined in column 3. The AND operator is a binary operator — that is, it requires two operands, o1 and o2. If both o1 and o2 are true, then (o1 && o2) is true (row1). If either o1 or o2 or both o1 and o2 are false, then the expression (o1 && o2) is false (rows 2, 3 and 4). So, the only case in which (o1 && o2) is true is when both o1 and o2 are true (row 1).
The boolean OR operation (column 4) is also a binary operation. If both o1 and o2 are false, then is false (row 4). If either o1 or o2 or both o1 and o2 are true, then the expression is true (rows 1-3). So, the only case in which is false is when both o1 and o2 are false.
The boolean EXCLUSIVE-OR (XOR) operation (column 5) is a binary operation, which differs from the OR operator in that it is true when either o1 or o2 is true (rows 2 and 3), but it is false when both o1 and o2 are true (row 1).
The NOT operation (column 6) is a unary operator — it takes only one operand— and it simply reverses the truth value of its operand. Thus, if o1 is true, !o1 is false, and vice versa.
In order to evaluate complex boolean expressions, it is necessary to understand the order in which boolean operations are carried out by the computer. For example, what is the value of the following expression?
The value of this expression depends on whether we evaluate the first or the && first. If we evaluate the first, the expression’s value will be false; if we evaluate the && first, the expression’s value will be true. In the following example, we use parentheses to force one operation to be done before the other:
As these evaluations show, we can use parentheses to force one operator or the other to be evaluated first. However, in Java, the && operator has higher precedence than the operator. Therefore, the second alternative corresponds to the default interpretation that Java would apply to the expression that has no parentheses. In other words, given the expression true || true && false, the AND operation would be evaluated before the OR operation even though the OR operator occurs first (i.e., to the left) in the unparenthesized expression.
As this example illustrates, the boolean operators have a built-in precedence order which is used to determine how boolean expressions are to be evaluated. The precedence rules are set out in Table 5.2.2.
In addition to operator precedence, it is necessary to know about an operator’s associativity in order to evaluate boolean expressions of the form (op1 || op2 || op3). Should this expression be evaluated as ((op1 || op2) || op3) or as (op1 || (op2 || op3))}?
Another important feature of the boolean operators is that they utilize a form of evaluation known as short-circuit evaluation, in which a boolean expression is evaluated from left to right, and the evaluation is discontinued as soon as the expression’s value can be determined, regardless of whether it contains additional operators and operands. For example, in the expression
In addition to being a more efficient form of evaluating boolean expressions, short-circuit evaluation has some practical uses. For example, we can use short-circuit evaluation to guard against null pointer exceptions. Recall from Chapter 2 that a null pointer exception results when you try to use an uninstantiated reference variable — that is, a reference variable that has not been assigned an object. For example, if we declare a OneRowNim variable without instantiating it and then try to use it, a null pointer exception will result:
In this code, a null pointer exception results when we use game in the method call game.gameOver(). We can use short-circuit evaluation to prevent the exception from occurring:
