Skip to main content

Computational Problem Solving with Java and Interactive Object Graphics

Mark F. Russo, PhD

Section 2.11 Logical Expressions

Java provides three operators that you can use to form logical expressions:
Table 2.11.1. Java Logical Operators
Operator Type Description
&& infix, binary Logical conjunction (AND)
|| infix, binary Logical disjunction (AND)
! prefix, unary Negation (NOT)
Logical expressions combine subexpressions using logical operators. All input operands for logical operators must be boolean in type, and logical expressions always evaluate to a boolean value. In short, when it comes to logical expressions, its booleans in and booleans out.
Logical operator precedence is lower than relational operators. That means that relational subexpressions involving inequalities used as operands for a logical operator, will be evaluated before the logical operator is evaluated. This is a good thing because relational expressions evaluate exclusively to booleans and logical expression operands are exclusively boolean, so the two work together nicely.
With the conjunction operator (&&), if both the first operand AND the second operand both evaluate to true, then the conjunction expression evaluates to true. If either the first or second operand evaluates to false, then the conjunction expression is false.
jshell> true && true;
$1 ==> true
|  created scratch variable $1 : boolean

jshell> true && false;
$2 ==> false
|  created scratch variable $2 : boolean
 
jshell> false && true;
$3 ==> false
|  created scratch variable $3 : boolean
 
jshell> false && false;
$4 ==> false
|  created scratch variable $4 : boolean
The above can be summarized as a truth table.
Table 2.11.2. Truth Table for Conjunction (&&)
A B A && B
true true true
true false false
false true false
false false false
As an example, if day is a variable holding the number of the day in any given month following is a logical expression that tells us to pay the rent during the first week of the month: day >= 1 && day <=7.
The disjunction operator (||) is similar. If either the first operand OR the second operand evaluates to true, then the disjunction expression evaluates to true. If both the first and second operand evaluates to false, then the disjunction expression is false.
jshell> true || true;
$1 ==> true
|  created scratch variable $1 : boolean

jshell> true || false;
$2 ==> true
|  created scratch variable $2 : boolean

jshell> false || true;
$3 ==> true
|  created scratch variable $3 : boolean

jshell> false || false;
$4 ==> false
|  created scratch variable $4 : boolean
The above also can be summarized as a truth table.
Table 2.11.3. Truth Table for Disjunction (||)
A B A || B
true true true
true false true
false true true
false false false
A comfortable water temperature for an adult to swim laps in a pool is between 78°F and 82°F. What is an expression that tells me when to avoid swimming laps in a pool based on its water temperature? If tempF is the water temperature in °F, tempF < 78 || tempF > 82. If either of these relational expressions is true, we’ll go out for a run instead.
Negation ! is the simplest of the Java logical operators. This prefix unary operator turns a true value into false and a false value into true. Consider the following example and truth table.
jshell> !true;
$1 ==> false
|  created scratch variable $1 : boolean

jshell> !false;
$2 ==> true
|  created scratch variable $2 : boolean
Table 2.11.4. Truth Table for Negation (!)
A !A
true false
false true
Let’s consider a few more practical examples of logical expressions.
Test if age is greater than 17 AND less than or equal to 67.
Logical expression: age > 17 && age <= 67 
jshell> int age = 40;
age ==> 40
|  created variable age : int

jshell> age > 17 && age <= 67;  // Logical test
$2 ==> true
|  created scratch variable $2 : boolean

jshell> age = 12;
age ==> 12
|  assigned to age : int

jshell> age > 17 && age <= 67;  // Logical test
$4 ==> false
|  created scratch variable $4 : boolean
Test if age is less-than or equal-to 17 OR greater than 67.
Logical expression: age <= 17 || x > 67 
jshell> int age = 40;
age ==> 40
|  created variable age : int

jshell> x <= 17 || x > 67;          // Logical test
$2 ==> false
|  created scratch variable $2 : boolean

jshell> age = 12;
age ==> 12
|  assigned to age : int

jshell> age <= 17 || x > 67;        // Logical test
$4 ==> true
|  created scratch variable $4 : boolean

jshell> age = 70;
age ==> 70
|  assigned to age : int

jshell> age <= 17 || x > 67;        // Logical test
$6 ==> true
|  created scratch variable $6 : boolean

jshell>
Are the last two examples complementary? Is the truth table of one expression equal to the negated truth table of the other? Let’s check.
Logical expression: !(age <= 17 || age > 67) == (age > 17 && age <= 67) 
jshell> int age = 40;
age ==> 40
|  created variable age : int

jshell> !(age <= 17 || age > 67) == (age > 17 && age <= 67);
$2 ==> true
|  created scratch variable $2 : boolean

jshell> age = 12;
age ==> 12
|  assigned to aeg : int

jshell> !(age <= 17 || age > 67) == (age > 17 && age <= 67);
$4 ==> true
|  created scratch variable $4 : boolean

jshell> age = 70;
age ==> 70
|  assigned to age : int

jshell> !(age <= 17 || age > 67) == (age > 17 && age <= 67);
$6 ==> true
|  created scratch variable $6 : boolean

jshell>
Forming logical expressions to test complex conditions takes practice. The more you practice the better you’ll be able to form the expressions you need to solve your computing problems.

Subsection 2.11.1 Practice

You’ve invented a dart game that awards a different number of points to a player when a dart lands within each of four concentric circles. The game board is 600mm by 600mm, so the center is at (300mm, 300mm). The outer (yellow) band is bounded by circles with radii 180mm and 240mm and has a point value of 1. This next (blue) band is bounded by circles with radii 120mm and 180mm and has a point value of 2. This next (green) band is bounded by circles with radii 60mm and 120mm and has a point value of 3. And the center (red) circle has radius of 60mm with a point value of 4. The game board is instrumented with sensors; it reports the (x, y) coordinates in mm when any dart lands.
On the right is an interactive illustration of your game board. Click anywhere on the illustration to see the coordinates that the board senses.
Write a logical expression that evaluates to true if a dart lands within the centermost circle, centered at (300, 300) with radius 60, and false otherwise. Write a second logical expression that evaluates to true if a dart lands within the next circular band (green) between circles with radii 60mm and 120mm.
Figure 2.11.5. Dart Game Board
We can test if a point is within a circle by checking if the distance between a point and the center of the circle is less than the radius of the circle. The distance formula \((distance = \sqrt{(x_1 - x_2)^2 + (y_1 - y_2)^2})\) gives us the way to compute the distance between \((x_1, y_1)\) and \((x_2, y_2)\text{,}\) where one of the two points will be chosen as the circle center and the other is the point we are testing. Because our game board is a set of nested circles, the distance formula will be an integral part of our logical expressions.
A simple relational expression will tell us if a dart’s landing coordinate falls within the centermost circle. It is convenient to compute the distance to the circle center first and save it to a temporary variable, and then test the value of that distance variable. The following code snippet initializes variables, computes distance, and tests that distance to see if the dart has landed in the centermost circle. Note how we have organized these computations as a sequence of steps.
// Circle parameters
double xc = 300.0, yc = 300.0;

// Dart coordinates
double x1 = 210.0, y1 = 319.0;

// Compute distance
double dist = Math.sqrt( Math.pow(x1-xc, 2) + Math.pow(y1-yc, 2) );

// Test
dist < 60;
Let’s test the logic interactively using JShell.
jshell> // Circle parameters
...> double xc = 300.0, yc = 300.0;
 xc ==> 300.0
 yc ==> 300.0

 jshell> // Dart coordinates
    ...> double x1 = 210.0, y1 = 319.0;
 x1 ==> 210.0
 y1 ==> 319.0

 jshell> // Compute distance
    ...> double dist = Math.sqrt( Math.pow(x1-xc, 2) + Math.pow(y1-yc, 2) );
 dist ==> 91.98369420718001

 jshell> // Test if in center red circle
    ...> dist < 60;
 false
The final false tells us that the dart did not land in the centermost circle.
How about the next outer circular band with radius greater than or equal to 60 but less than 120. This test is more complex because two conditions must be true simultaneously in order for the dart to have landed in the green band. Here is the logical expression to be evaluated.
// Test if in green circle
dist >= 60 && dist < 120;
Enter this into our previous JShell session.
jshell> dist >= 60 && dist < 120;
true
The dart has landed in the green band. The player is awarded 3 points.

Activity 2.11.1.

Demonstrate the following two De Morgan’s laws using Java logical expressions.
  • \(\displaystyle not (A\ or\ B)\ =\ (not\ A)\ and\ (not\ B)\)
  • \(\displaystyle not (A\ and\ B)\ =\ (not\ A)\ or\ (not\ B)\)
Answer.
jshell> boolean A, B;
A ==> false
|  created variable A : boolean
B ==> false
|  created variable B : boolean

jshell> !(A || B) == (!A && !B)
$3 ==> true
|  created scratch variable $3 : boolean

jshell> A = true
A ==> true
|  assigned to A : boolean

jshell> !(A || B) == (!A && !B)
$5 ==> true
|  created scratch variable $5 : boolean

jshell> B = true
B ==> true
|  assigned to B : boolean

jshell> !(A || B) == (!A && !B)
$7 ==> true
|  created scratch variable $7 : boolean

jshell> A = false
A ==> false
|  assigned to A : boolean

jshell> !(A || B) == (!A && !B)
$9 ==> true
|  created scratch variable $9 : boolean

jshell> A = B = false;
A ==> false
|  assigned to A : boolean

jshell> !(A && B) == !A || !B;
$11 ==> true
|  created scratch variable $11 : boolean

jshell> A = true;
A ==> true
|  assigned to A : boolean

jshell> !(A && B) == !A || !B;
$13 ==> true
|  created scratch variable $13 : boolean

jshell> B = true;
B ==> true
|  assigned to B : boolean

jshell> !(A && B) == !A || !B;
$15 ==> true
|  created scratch variable $15 : boolean

jshell> A = false;
A ==> false
|  assigned to A : boolean

jshell> !(A && B) == !A || !B;
$17 ==> true
|  created scratch variable $17 : boolean

jshell>
<Prev^TopNext>