# Building Java Programs, 3rd edition

## Lab: Boolean logic

Except where otherwise noted, the contents of this document are Copyright 2013 Stuart Reges and Marty Stepp.

lab document created by Marty Stepp, Stuart Reges and Whitaker Brand

# Lab goals

Goals for this problem set:

• use `boolean` expressions and variables to represent logical true/false expressions
• Where you see this icon, you can click it to check the problem in Practice-It!

# The `boolean` type

The `boolean` type represents logical values of `true` or `false`. Combine `boolean` expressions with logical operators `&&` (and), `||` (or), and `!` (not).

Example:

```boolean test1 = 7 < 10;            // true
boolean test2 = (1 == 2);          // false
if ((test1 || test2) && 2 + 2 != 5) {
System.out.print("hello");     // output: hello
}
```

# `String` methods with `boolean` results

Method name Description
string`.equals(string)` whether the two strings are identical
string`.equalsIgnoreCase(string)` whether the two strings are identical, ignoring capitalization
string`.startsWith(string)` whether this string begins with the characters of the given string
string`.endsWith(string)` whether this string ends with the characters of the given string
string`.contains(string)` whether the characters of the given string occur within this string
```String name = "Professor Smith";
if (name.startsWith("Prof")) {
}
```

# Exercise : Boolean Expressions

Write the result of each expression as either `true` or `false`, given the following variables.

```int x = 12;
int y = 7;
int z = 28;
String s = "mid term";
```
 `x < 14` `true` `!(x % 2 < 1)` `false` `x < y || x < z` `true` `z / x < x / y * x` `true` `s.length() == y` `false` `s.toUpperCase().equals("MID TERM")` `true` `!s.equals("mid term") || x * y != z` `true` `s.substring(z / x).length() > y` `false`

# Exercise : allDigitsOdd

Write a method named `allDigitsOdd` that returns whether every digit of a positive integer is odd. Your method should return `true` if the number consists entirely of odd digits and `false` if any of its digits are even. 0, 2, 4, 6, and 8 are even digits, and 1, 3, 5, 7, 9 are odd digits.

For example, `allDigitsOdd(135319)` returns `true` but `allDigitsOdd(9145293)` returns `false`.

Hint: You can pull apart a number into its digits using ```/ 10``` and `% 10`.

# Exercise : hasMidpoint

Write a method `hasMidpoint` that accepts three integers as parameters, and returns `true` if one of the numbers is the midpoint of the other two and returns `false` otherwise.

For example, the call `hasMidpoint(3, 7, 5)` would return `true` because one of the parameters (5) is the midpoint of the other two (3 and 7).

Try to solve this problem in Practice-It: click on the check-mark above!

# Exercise : before

Write a method `before` that takes as parameters two month/day combinations and that returns whether or not the first date comes before the second date (`true` if the first month/day comes before the second month/day, `false` if it does not). The method will take four integers as parameters that represent the two month/day combinations.

The first integer in each pair represents the month and will be a value between 1 and 12 (1 for January, 2 for February, etc, up to 12 for December). The second integer in each pair represents the day of the month (a value between 1 and 31). One date is considered to come before another if it comes earlier in the year.

Solve this problem in Practice-It by clicking on the check-mark above.

# Exercise : sameDashes

Write a method `sameDashes` that takes two strings as parameters and that returns whether or not they have dashes in the same places (returning `true` if they do and returning `false` otherwise). For example, below are four pairs of strings of equal length that have the same pattern of dashes. Notice that the last pair has no dashes at all.

```string 1:    "hi--there-you."    "-15-389"    "criminal-plan"    "abc"
string 2:    "12--(134)-7539"    "-xy-zzy"    "(206)555-1384"    "9.8"
```
To be considered a match, the strings must have exactly the same number of dashes in exactly the same positions. The Strings might be of different length.

Solve this problem in Practice-It by clicking on the check-mark above.

# Exercise : "Boolean Zen"

This attempted solution to Self-Check 5.15 (`isVowel`) has several problems:

```// Returns whether the given string represents a vowel:
// a, e, i, o, or u, case insensitively.
public static boolean isVowel(String s) {
if (s == "a") {
return true;
} else if (s == "e") {
return true;
} else if (s == "i") {
return true;
} else if (s == "o") {
return true;
} else if (s == "u") {
return true;
} else {
return false;
}
}
```

Open Practice-It from the link above, copy/paste this code into it, then see the next slide.

# Exercise - things to fix

Fix the following aspects of the code:

• It has a bug related to how strings are compared.
• It isn't case sensitive; it fails for uppercase vowels.
• It has too many unnecessary if/else statements.
• (advanced) It does not use "Boolean Zen" as described in textbook section 5.3.

```public static boolean isVowel(String s) {
s = s.toLowerCase();
if (s.equals("a") || s.equals("e") || s.equals("i")
|| s.equals("o") || s.equals("u")) {
return true;
} else {
return false;
}
}
```

The above can be improved. "Boolean Zen" version:

```public static boolean isVowel(String s) {
s = s.toLowerCase();
return s.equals("a") || s.equals("e") || s.equals("i")
|| s.equals("o") || s.equals("u");
}
```

# Exercise : assertions

Identify whether each assertion is always/never/sometimes `true` at each point.

`x > y` `z == 0` `x == y`
A
B
C
D
E
```public static void mystery(int x, int y) {
int z = 0;

// Point A
while (x != y) {
// Point B
z++;

if (x > y) {
// Point C
x = x / 10;
} else {
// Point D
y = y / 10;
}
}

// Point E
System.out.println(x + " " + y + " " + z);
}
```

You can also solve this problem in Practice-It by clicking on the check-mark above.