CISC 1115 Boolean & Logical Operators

CISC 1115
Introduction to Programming Using Java
Boolean & Logical Operators

Reading from the Text

Chapter 5 Sections 5.1, 5.5 to end of the chapter

Relational Operators

Operators forming conditions (true/false statements)
Used as the condition expression of a conditional (if statement) and for loop

Java's Relational Operators

== — Equality
!= — Inequality
<
>
<=
>=

Note: to compare Strings, use the equals method (of the String class), rather than ==. (There are other methods for greater, less, etc — we'll cover them later):

String s1, s2;
…
s1 = …
…
s2 = …
…
if (s1.equals(s2))	// NOT s1 == s2
	…
…

Logical Operators

There are some tests that require more than a single decision/condition.
Logical operators can be used to build larger, more complex conditions from simpler ones.

Program P06.1 Vaccines

A medical office has hired us to write a program to screen out patients who should not be receiving the swine flu vaccine. The Department of Health has determined that children under the age of 3 and seniors over the age of 65 should NOT be receiving the vaccine. The program should prompt the user for the patients age and print out whether the vaccine may be administered.

import java.util.*;

public class Vaccines {
        public static void main(String [] args) {
                Scanner scanner = new Scanner(System.in);

                System.out.print("Enter patient's age: ");
                int age = scanner.nextInt();;

                if (age < 3 || age > 65)
                        System.out.println( "***** Do NOT ADMINISTER VACCINE *******");
                else
                        System.out.println( "Go ahead and stick it to 'em");
        }
}

Java's Logical Operators

! 'Not' operator: true if operand is false; false if operand is true
&& 'And' operator: true only if both operands are true
|| 'Or' operator: true if either or both operands are true
^ 'Xor' operator: true if either but not both operands are true

Note: && has higher precedence than ||.

DeMorgans Laws

The following two laws of logical operators often helps clean up a complex expression (or make it more understandable):

If a and b are conditions, then:

!(a && b) is the same as !a || !b
- (By is the same as we mean that given the same operands, the two expressions always evaluate to the same result)
- !(x == 6 && y == 8) is the same as !(x == 6) || !(y == 8)
  - The above is better expressed using !=: x != 6 || y != 8
!(a || b) is the same as !a && !b
- !(x == 6 || y == 8) is the same as !(x == 6) &&| !(y == 8)
  - The above is better expressed using !=: x != 6 && y != 8

the condition "it is not the case that age is less than or equal to 3 or age is greater than or equal to 65"

if !(age <= 3 || age >= 65)

transforms to (by DeMorgan's Law):

if (!(age <=3) && !(age >= 65))

which then transforms to (through an understanding of the relational operators):

if (age > 3 && age < 65)

Short-circuiting

The expression a && b is always false when the condition a is false.
- Therefore, in the above expression, if a is false, there is no reason to check whether b is true or not.
Similarly, the expression a || b is always true when a is true.
- Therefore, in the above expression, if a is true, there is no reason to check whether b is true or not.
The above two rules (not checking the second opernd depending on the logical operator and the value of the first operand) is called short-circuiting

Program P06.2 — Payroll

Write a program that scans a payroll file for discrepancies. The payroll file-- named payroll.dataconsists of a header value for the number of employees followed by the the following data for each employee:

Id (int)
Last name (string)
First Name (string)
Full or part-time (String "f" or "p")
hourly rate or annual salary (int)

Occasionally, the data entry people make a mistake and enter an annual salary for a part-timer, or an hourly rate for a full-time. No part-timer should have an hourly rate of greater than $50 and similarly, no full-timer earns less than $10,000.

The program should scan the file, and print out the info for any employee whose payroll record seems incorrect.

import java.io.*;
import java.util.*;

public class Payroll {
        public static void main(String [] args) throws Exception {
                Scanner scanner = new Scanner(new File("payroll.data"));

                int numEmployees = scanner.nextInt();

                for (int i = 1; i <= numEmployees; i++) {

                        int id = scanner.nextInt();
                        String lastName = scanner.next();
                        String firstName = scanner.next();;
                        String status = scanner.next();;
                        int amount = scanner.nextInt();;

                        if (status.equals("f") && amount < 10000 ||
                                        status.equals("p") && amount > 50)
                                System.out.println("Possibly corrupt record for employee " + lastName + ", " + firstName + " (" + id + ")");
                }
        }
}

Program P06.3 — Payroll

Rewrite Program 6.2 so that it calls a method, isDataCorrupt to determine whether the data is possibly corrupt.

import java.io.*;
import java.util.*;

public class Payroll {
        public static void main(String [] args) throws Exception {
                Scanner scanner = new Scanner(new File("payroll.data"));

                int numEmployees = scanner.nextInt();

                for (int i = 1; i <= numEmployees; i++) {

                        int id = scanner.nextInt();
                        String lastName = scanner.next();
                        String firstName = scanner.next();;
                        String status = scanner.next();;
                        int amount = scanner.nextInt();;

                        if (isDataCorrupt(status, amount) )
                                System.out.println("Possibly corrupt record for employee " + lastName + ", " + firstName + " (" + id + ")");
                }
        }

        public static boolean isDataCorrupt(String status, int amount) {
                if (status.equals("f") && amount < 10000 ||
                                status.equals("p") && amount > 50)
                        return true;
                return false;
        }
}

Type `boolean`

Given the declarations:

int i, j, k;
double d, e, f;
string s, t, u;

Consider the types of the following expressions:

Expression	Type
3	`int`
4.6	`double`
"Hello"	`string`
i+j	`int`
i/j	`int`
d/e	`double`
i/d	`double`
s	`string`

But what about

Expression Type
i < j ???
i == 6 ???
d > e && f < 4.8 ???
i < 3 || i > 65 ???

Boolean

Boolean - values of a true/false nature
Boolean value - true / false
Logical / boolean expressions - expressions that evaluate to true/false.
Logical/boolean Operators - operators whose operands are boolean expressions
Boolean-valued methods - methods that return a boolean value (true/false)

Java's Boolean Type - `boolean`

boolean b;

Two literals - true and false
```
b = false;
....
b = true;
		
```
It's the data type of the conditions of if statements and for loops

But boolean values can also be used as regular variables

boolean isEligibleToRetire;
int age;
...

if (age >= 62)
	isEligibleToRetire = true;
else
	isEligibleToRetire = false;
...

if (isEligibleToRetire)
	System.out.println("May retire");

More elegantly ("speaking Boolean")::

boolean isEligibleToRetire;
int age;
...

isEligibleToRetire = age >= 62;
...

if (isEligibleToRetire)
	System.out.println("May retire");

Program 6.4

Rewrite Program 6.3 so that the method sets a boolean variable, isCorrupted, to true/false and then uses that variable as the return value.

import java.io.*;
import java.util.*;

public class Payroll {
        public static void main(String [] args) throws Exception {
                Scanner scanner = new Scanner(new File("payroll.data"));

                int numEmployees = scanner.nextInt();

                for (int i = 1; i <= numEmployees; i++) {

                        int id = scanner.nextInt();
                        String lastName = scanner.next();
                        String firstName = scanner.next();;
                        String status = scanner.next();;
                        int amount = scanner.nextInt();;

                        if (isDataCorrupt(status, amount) )
                                System.out.println("Possibly corrupt record for employee " + lastName + ", " + firstName + " (" + id + ")");
                }
        }

        public static boolean isDataCorrupt(String status, int amount) {
                boolean isCorrupted;
                if (status.equals("f") && amount < 10000 ||
                                status.equals("p") && amount > 50)
                        isCorrupted = true;
                else
                        isCorrupted = false;
                return isCorrupted;
        }
}

Program 6.5

Rewrite Program 6.4 so that the method returns the boolean expression directly.

import java.io.*;
import java.util.*;

public class Payroll {
        public static void main(String [] args) throws Exception {
                Scanner scanner = new Scanner(new File("payroll.data"));

                int numEmployees = scanner.nextInt();

                for (int i = 1; i <= numEmployees; i++) {

                        int id = scanner.nextInt();
                        String lastName = scanner.next();
                        String firstName = scanner.next();;
                        String status = scanner.next();;
                        int amount = scanner.nextInt();;

                        if (isDataCorrupt(status, amount) )
                                System.out.println("Possibly corrupt record for employee " + lastName + ", " + firstName + " (" + id + ")");
                }
        }

        public static boolean isDataCorrupt(String status, int amount) {
                return status.equals("f") && amount < 10000 || status.equals("p") && amount > 50;
        }
}

The Conditional Operator

A common form of if/else is:

if (<condition>)
	x = <value₁>
else
	x = <value₂>

i.e., assigning different values to the same variable (x in this case) based on some condition.

This form can be thought of as expressing: x should be assigned <value₁> if <condition> is true and <value₂> otherwise
Java has a concise and elegant way of expressing this sort of conditional, known as the conditional operator (?:):
```
<condition> ? <value₁> : <value₂>
		
```
- Notice that the operator has two symbols: ? and :, and three operands, the condition and two values
- The semantics of this operator is: test the condition; if true the result of the operation is the first value (the one after the ?); otherwise the result of the operation is the second value (the one after the :)
- Like any other operator, this can appear in subexpressions
- There must be a true AND a false value

Write the expression for the absolute value of x as a conditional operator

x >= 0 ? x : -x

Write the expression for classic assignment of a letter grade based on an average

average >= 90 ? 'A' : average >= 80 ? 'B' : average >= 70 ? 'C' : average >= 60 ? 'D' : 'F'

Notes

Here is the above expression parenthesized for clarity

	average >= 90 ? 'A' : (average >= 80 ? 'B' : (average >= 70 ? 'C' : (average >= 60 ? 'D' : 'F')))

CISC 1115
Introduction to Programming Using Java
Boolean & Logical Operators

Reading from the Text

Chapter 5

Sections 5.1, 5.5 to end of the chapter

More on Operators

Relational Operators

Java's Relational Operators

Logical Operators

Program P06.1 Vaccines

Java's Logical Operators

DeMorgans Laws

Short-circuiting

Type `boolean`

Boolean

Java's Boolean Type - `boolean`

Program 6.4

Program 6.5

The Conditional Operator

Files used in Lecture 6

Lab for Lecture 6

CISC 1115 Introduction to Programming Using Java Boolean & Logical Operators

Reading from the Text

Chapter 5

Sections 5.1, 5.5 to end of the chapter

More on Operators

Relational Operators

Java's Relational Operators

Logical Operators

Program P06.1 Vaccines

Java's Logical Operators

DeMorgans Laws

Short-circuiting

Type boolean

Boolean

Java's Boolean Type - boolean

Program 6.4

Program 6.5

The Conditional Operator

Files used in Lecture 6

Lab for Lecture 6

CISC 1115
Introduction to Programming Using Java
Boolean & Logical Operators

Type `boolean`

Java's Boolean Type - `boolean`