1. Chapter 4 : Conditionals

2. Objectives
After studying this chapter you should understand the following:
the notions of preconditions, postconditions, and invariants;
the purpose of a conditional statement;
the function of boolean expressions;
the purpose of a compound statement.
Also, you should be able to:
write and evaluate boolean expressions;
write conditional statements of various forms;
implementation methods that use conditional statements;
implement a class tester which automatically verifies test results.
May 2004
NH-Chapter4

3. Postconditions and invariants
Method currentCount in Counter is specified as
/**
* The number of items counted. */
public int currentCount () { …
Specification stipulates invoking method returns a value of type int.
May 2004
NH-Chapter4

4. Postconditions and invariants
Can be more precise in specifying result : integer result is non negative.
/**
* The number of items counted. *
this.currentCount() >= 0 */
public int currentCount () { …
Postcondition: condition that implementor promises will be satisfied when method completes execution.
Implementor must make sure that the method satisfies the postcondition.
May 2004
NH-Chapter4

5. Postconditions and invariants
Need to make sure instance variable used to store current count will never contain a negative value.
Document this via a class invariant:
private int count; // current count
// invariant: count >= 0
A class invariant will always be true of all instances of the class.
May 2004
NH-Chapter4

6. Postconditions and invariants
If we add decrementCount to Counter:
public void decrementCount ()
Decrement positive count by 1; zero count remains zero.
In implementation, need to add guard to be sure not to decrement when count == 0
May 2004
NH-Chapter4

7. The if-then statement if (condition) statement true condition falseB E G I N
true
condition
false
statement E N D
May 2004
NH-Chapter4

8. Implemeting decrementCount
/**
* Decrement positive count by 1;
* zero count remains zero */
public void decrementCount () {
if (count > 0)
count = count - 1; }
May 2004
NH-Chapter4

9. Explorer: invariants and guards
Restrict Explorer’s tolerance to be a non-negative integer.
private int tolerance; // current tolerance
// invariant: tolerance >= 0
/**
* Damage (hit points) required to defeat
* this Explorer. *
tolerance >= 0 */
public int tolerance () {
return tolerance; }
Need to insure value assigned in each case is not negative.
May 2004
NH-Chapter4

10. Explorer: invariants and guards
Consider method takeThat.
Need to guard the two statements:
if (hitStrength <= tolerance)
tolerance = tolerance - hitStrength;
if (hitStrength > tolerance)
tolerance = 0;
But, only one of those should execute when invoking takeThat.
May 2004
NH-Chapter4

11. if-then-else statement
if (condition)
statement1
else
statement2 B E G I N
false
true
condition
statement 2
statement 1 E N D
May 2004
NH-Chapter4

12. Implementing method takeThat
public void takeThat (int hitStrength) {
if (hitStrength <= tolerance)
tolerance = tolerance - hitStrength;
else
tolerance = 0; }
May 2004
NH-Chapter4

13. Implementing constructor
public Explorer (String name, Room location, int strength, int tolerance) { …
if (tolerance >= 0)
this.tolerance = tolerance;
else
this.tolerance = 0; }
May 2004
NH-Chapter4

14. Compound statements if (condition) { statement1 … statementN }
} else {
statement21
statement2M }
May 2004
NH-Chapter4

15. Conditions: boolean expressions
Produce boolean values when evaluated;
Evaluate to true or false.
Can declare boolean variables, and assign values:
private boolean tooBig;
And can assign values to it:
tooBig = true; Or
tooBig = size > 10;
May 2004
NH-Chapter4

16. Handling multiple cases
A conditional statement divides problem into two cases to be considered independently.
In many problems, there are more than two cases, or cases need to be further divided into subcases.
Use nesting conditional statements.
May 2004
NH-Chapter4

17. Handling multiple cases
Assume class Date with properties day, month,year.
Implement a Date’s query that will tell whether or not a date occurs in a leap year.
public boolean isLeapYear ()
This Date occurs in a leap year.
May 2004
NH-Chapter4

18. Handling multiple cases
isLeapYear
Case: year divisible by 4
???
Case: year not divisible by 4
not a leap year.
Case: divisible by 100
???
Case: not divisible by
100 is leap
Case: divisible by 400 is leap
Case: not divisible by 400 is not leap
May 2004
NH-Chapter4

19. Handling multiple cases
// This Date occurs in a leap year.
public boolean isLeapYear () {
boolean aLeapYear;
if (year % 4 == 0)
if (year % 100 == 0)
// if divisible by 100,
// must also be divisible by 400
aLeapYear = (year % 400 == 0);
else // divisible by 4, not by 100
aLeapYear = true;
else // not divisible by 4
aLeapYear = false;
return aLeapYear; }
May 2004
NH-Chapter4

20. Cascading conditionals
When problem splits into more than two cases:
“cascade” if-then-else statements.
if (case1)
handleCase1
else if (case2)
handleCase2 …
else if (penultimateCase)
handlePenultimateCase
else
handleLastCase
May 2004
NH-Chapter4

21. TrafficLight’s change() method:
case: light is YELLOW
change to RED
case: light is RED
change to GREEN
case: light is GREEN
change to YELLOW
May 2004
NH-Chapter4

22. TrafficLight’s change() method
public void change () {
if (light == GREEN)
light = YELLOW;
else if (light == YELLOW)
light = RED;
else // light == RED
light = GREEN; }
May 2004
NH-Chapter4

23. Dangling else There is an ambiguity as to whether the structure
if (condition1)
if (condition2)
statement1
else
statement2
Is it an if-then nested in an if-then-else, or an if-then-else nested in an if-then?
May 2004
NH-Chapter4

24. Dangling else
May 2004
NH-Chapter4

25. Dangling else: equivalent statements
if (condition1)
if (condition2)
statement1
else
statement2
if (condition1) {
if (condition2)
statement1
else
statement2 }
May 2004
NH-Chapter4

26. Example: combination lock
Responsibilities:
Know:
The combination
whether unlocked or locked
Do:
lock
unlock
May 2004
NH-Chapter4

27. CombinationLock class
Class: CombinationLock
Queries:
is open
Commands:
lock
unlock
May 2004
NH-Chapter4

28. Class CombinationLock specifications
public class CombinationLock
Contructor:
public CombinationLock (int combination)
Queries:
public boolean isOpen()
Commands:
public void close ()
public void open(int combination)
May 2004
NH-Chapter4

29. Class CombinationLock implementation
Component variables:
private int combination;
private boolean isOpen;
May 2004
NH-Chapter4

30. Structure for a simple test
public class CombinationLock {
private int combination;
private boolean isOpen;
public CombinationLock (int combination) { }
public boolean isOpen () {
return true;
public void close () {
public void open (int combinationToTry) {
May 2004
NH-Chapter4

31. Structure for a simple test
class CombinationLockTest {
private CombinationLock lock;
public CombinationLockTest () { }
public void runTest () {
public class TestCombinationLock {
public static void main (String[] argv) {
(new CombinationLockTest()).runTest(); }
May 2004
NH-Chapter4

32. Precondition
A condition client of a method must make sure holds when method is invoked.
“Require”s : Constructor and method enter have requirements that clients must meet for them to execute properly.
May 2004
NH-Chapter4

33. Constructor specifications
/**
* Create a lock with the specified combination. *
* 0 <= combination && combination <= 999
* this.isOpen() */
public CombinationLock (int combination) …
May 2004
NH-Chapter4

34. Testing locks Invoke this method in runTest for each lock to test.
Need method to create and test lock with given combination:
private void testLock (int combination)
Test a lock with the specified combination.
Invoke this method in runTest for each lock to test.
public void runTest () {
testLock(0);
testLock(123);
testLock(999); }
May 2004
NH-Chapter4

35. Automating checking of test results
private void verify (boolean test, String message) {
if (!test)
System.out.println(
"Verification failed: " + message); }
May 2004
NH-Chapter4

36. testLock method
testLock method must create lock and run initial state test:
private void testLock (int combination) {
lock = new CombinationLock(combination);
testInitialState(); }
May 2004
NH-Chapter4

37. testLock method Initial state test should make sure that lock is open.
So, instead of writing the test method:
private void testInitialState() {
System.out.println("Initial state: " +
lock.isOpen()); }
Write:
private void testInitialState() {
verify(lock.isOpen(), "initial state"); }
May 2004
NH-Chapter4

38. Class CombinationLock implementation
The straightforward implementations:
public CombinationLock (int combination) {
this.combination = combination;
this.isOpen = true; }
public boolean isOpen () {
return isOpen;
May 2004
NH-Chapter4

39. Class CombinationLock implementation
In constructor, there are two variables with same name.
Component variable and
local variable combination.
this.combination refers to component variable.
If variable does not include object reference this in front of it, it is a reference to local variable.
May 2004
NH-Chapter4

40. Class CombinationLock implementation
May 2004
NH-Chapter4

41. Method to test close
write method to test close, and invoke it from testLock:
private void testClose() {
lock.close();
verify(!lock.isOpen(), "close open lock");
verify(!lock.isOpen(), "close closed lock"); }
private void testLock (int combination) {
lock = new CombinationLock(combination);
testInitialState();
testClose();
May 2004
NH-Chapter4

42. Implementing close in Lock
Command close is also easy to implement:
public void close () {
isOpen = false; }
May 2004
NH-Chapter4

43. Method to test open Test for the method open: four cases to test:
closed lock, correct combination: lock opens;
open lock, correct combination: lock remains open;
closed lock, incorrect combination: lock remains closed.
open lock, incorrect combination: lock remains open;
Test depends on combination, so pass correct combination as argument:
private void testOpen (int combination)
May 2004
NH-Chapter4

44. testOpen method private void testOpen (int combination) {
int badCombination = (combination + 1) % 1000;
// test with correct combination:
lock.close();
lock.open(combination); // open closed lock
verify(lock.isOpen(), "open closed lock");
lock.open(combination); // open opened lock
verify(lock.isOpen(), "open opened lock");
// test with incorrect combination:
lock.open(badCombination); // try opened lock
verify(lock.isOpen(), "bad comb, opened lock");
lock.open(badCombination); // try closed lock
verify(!lock.isOpen(), "bad comb, closed lock"); }
May 2004
NH-Chapter4

45. testOpen method Add an invocation of this method to testLock:
private void testLock (int combination) {
lock = new CombinationLock(combination);
testInitialState();
testClose();
testOpen(combination); }
May 2004
NH-Chapter4

46. Method open implementation
The following implementation of open fails the tests.
public void open (int combination) {
isOpen = (this.combination == combination) }
test will produce the following output:
Verification failed: bad comb, opened lock
Root of problem: attempt to open an already opened lock with incorrect combination should not close it.
May 2004
NH-Chapter4

47. Method open implementation
Correct implementation of method uses a conditional statement that opens the lock if the combination is correct, and does nothing if the combination is not correct:
public void open (int combinationToTry) {
if (this.combination == combinationToTry)
isOpen = true; }
May 2004
NH-Chapter4

48. Digit by digit lock This lock has a 3 digit combination.
To open the lock, client provides the digits one at a time.
If client enters three digits of combination in order, lock opens.
It doesn’t matter how many digits client provides, as long as combination is given.
May 2004
NH-Chapter4

49. Digit by digit lock: combination 123
Digit Entered 4 1 2 3 7
Lock Status
closed
open
May 2004
NH-Chapter4

50. Digit by digit lock: combination 123
if client gives command close when combination has been partly entered,
Client Command Lock Status
enter closed
enter closed
close closed
enter ?
open
enter open
enter open
enter ?
command close resets lock, entire combination must be entered.
May 2004
NH-Chapter4

51. Digit by digit lock
If combination is 123 and digits are entered, we need three digits to open the lock:
Digit Entered Lock Status
1 closed (need 2-3 to open)
2 closed (need 3 to open)
2 closed (need to open)
If combination is 223 and the digits are entered, a 3 will still open the lock:
2 closed (need 2-3 to open)
2 closed (still need 3 to open)
May 2004
NH-Chapter4

52. Class CombinationLock
Constructor:
public CombinationLock (int combination)
require: combination >= 0 && combination <=999
Queries:
public boolean isOpen ()
Commands:
public void close ()
public void enter (int digit)
require: digit >=0 && digit <=9
May 2004
NH-Chapter4

53. CombinationLock responsibilities
Know:
the 3-digit combination.
whether locked or unlocked.
the last three digits entered.
Do:
lock.
unlock, when given the proper combination.
accept a digit.
May 2004
NH-Chapter4

54. Getting digits from integers.
Using % and / operators, can extract each digit.
Suppose combination 123.
123 % 10 -> 3
123 / 10 -> 12
12 % 10 -> 2
12 / 10 -> 1
% 10 gets last digit
/ 10 gets remaining digits.
May 2004
NH-Chapter4

55. CombinationLock implementation
private boolean isOpen; // lock is unlocked
private int digit1; // 1st combination digit
private int digit2; // 2nd combination digit
private int digit3; // 3rd combination digit
// invariant:
// digit1 >= 0 && digit1 <= 9 &&
// digit2 >= 0 && digit2 <= 9 &&
// digit3 >= 0 && digit3 <= 9
May 2004
NH-Chapter4

56. CombinationLock implementation
// last, secondToLast, thirdToLast are the last three
// digits entered, with last the most recent.
// a value of -1 indicates digit has not been entered.
private int last;
private int secondToLast;
private int thirdToLast;
// invariant:
// -1 <= last <= 9 &&
// -1 <= secondToLast <= 9 &&
// -1 <= thirdToLast <= 9
May 2004
NH-Chapter4

57. Combination is 223, and digits 2-2 have been entered to a closed lock
May 2004
NH-Chapter4

58. Implementing constructor
public CombinationLock (int combination) {
digit3 = combination % 10;
combination = combination / 10;
digit2 = combination % 10;
digit1 = combination / 10;
isOpen = true;
last = -1;
secondToLast = -1;
thirdToLast = -1 }
May 2004
NH-Chapter4

59. Implementing methods Query isOpen is the same as before.
public boolean isOpen () {
return isOpen; }
Command close must resets lock.
public void close () {
open = false;
last = -1;
secondToLast = -1;
thirdToLast = -1; }
May 2004
NH-Chapter4

60. Implementing method enter
public void enter (int digit) {
thirdToLast = secondToLast;
secondToLast = last;
last = digit;
if (thirdToLast == digit1 &&
secondToLast == digit2 && last == digit3)
isOpen = true; }
May 2004
NH-Chapter4

61. Relational operators
<= less than or equal
> greater than
>= greater than or equal
== equal (A single ‘=‘ denotes assignment.)
!= not equal
A relational expression consists of two expressions joined with a relational operator.
May 2004
NH-Chapter4

62. Relational expressions
Let i1=10, i2=-20, i3=30.
i1 <  true
i1 <= 10  true
i3 == i1  false
i1 != 2  true
i1 <  false
i2 > 0  false
2*i1 == i  true
i2*(-1) != i1+i1  false
May 2004
NH-Chapter4

63. Relational expressions
An expression like a<b<c is illegal.
int values are converted to double, in mixed type comparisons:
10 > 2.5  10.0 > 2.5  false
May 2004
NH-Chapter4

64. Relational expressions
floating point values are approximations for real numbers, avoid using equality or inequality operators with them.
(1.0/ / /6.0 +
1.0/ / /6.0) == 1.0  false
May 2004
NH-Chapter4

65. Reference equality and object equality
Operators == and != can be used to compare values of any type.
Comparing reference values must be of same type.
Counter counter1;
Counter counter2;
Explorer myHero;
counter1 == counter2 // legal
counter1 == myHero // compilation error
May 2004
NH-Chapter4

66. Reference equality and object equality
Two reference values are equal if they refer to same object.
How to check if two different objects are equal?
if string1, string2, and string3 are String variables,
string1 = "c";
string2 = "ab" + string1;
string3 = "a" + "bc";
string2 and string3 will reference two distinct objects.
string2 == string3  false
use String method equals,
string2.equals(string3)  true
May 2004
NH-Chapter4

67. Boolean operators Use : ! not && and || or ! booleanExpression
booleanExpression && booleanExpression
booleanExpression || booleanExpression
A boolean expression evaluates to true or false
May 2004
NH-Chapter4

68. The ! (not) operator “Not” reverses boolean values.
!true  false
!false  true
Given : i1=10;
!( i1 > 9)  !(true)  false
Beware: “Not” has high precedence.
! i1 > 9  (!i1) > 9  illegal
May 2004
NH-Chapter4

69. &&, || (and then, or else) operators
Given: i1=10;
(i1>10)||(i1==10)  false || true  true
(i1>10)||(i1<0)  false || false  false
(i1>0)&&(i1<5)  true && false  false
(i1>0)&&(i1<20)  true && true  true
May 2004
NH-Chapter4

70. &&, || (and then, or else) operators
&& and || have lower precedence than the relational operators.
Parentheses are still useful as they enhance readability.
i1 < i2 && i1 < i3 means
(i1 < i2) && (i1 < i3)
Using the “and then” operator, can express the condition that value of i1 is between 0 and 20:
(0 < i1) && (i1 < 20)
May 2004
NH-Chapter4

71. The && and || are lazy operators
They evaluate only the left operand only when that suffices.
Given i1=10;
(i1 < 10) && (i1 > 0)  false && (i1 > 0) false
(i1 < 11) || (i1 > 100) true || (i1 > 100) true
Right operands, (i1 > 0) and (i1 > 100), are not evaluated.
Useful when considering expressions like
(x == 0) || (y/x < 10)
If left operand is true, x is 0, evaluating right operand will result in an attempt to divide by 0 and a run-time error.
May 2004
NH-Chapter4

72. Operator precedence High Low unary +, unary -, ! *, /, % +, -
<, <=, >, >=
==, !=
&& ||
Low
May 2004
NH-Chapter4

73. DeMorgan’s Laws Useful for simplifying expressions.
!(b1 && b2)  !b1 || !b2
!(b1 || b2)  !b1 && !b2
!(i1>5 && i1<8)  !(i1>5) || !(i1<8)
May 2004
NH-Chapter4

74. Summary Introduced boolean expressions and conditional statements.
Conditional statements allow us to specify alternative computations and the circumstances under which each is to be performed.
The particular action to be done is determined by the processor at execution time, depending on the current data values.
May 2004
NH-Chapter4

75. Summary
The two forms of conditional statement we’ve seen are if-then and if-then-else.
if (condition)
statement
With an if-then-else, we specify two possible actions, one of which will be done:
if (condition)
statement1
else
statement2
May 2004
NH-Chapter4

76. Summary
Syntax of the Java language permits only a single statement as a conditional alternative.
Need a way to package a number of statements into one.
Compound statement: put braces around a sequence of statements:
{ statement1 statement2 … statementn }
May 2004
NH-Chapter4

77. Summary
Boolean expression: an expression that evaluates to a boolean value, true or false.
Several kinds of operators useful for constructing boolean expressions:
relational operators <, <=, >, and >=,
equality operators == and !=,
boolean operators &&, ||, and !.
May 2004
NH-Chapter4

78. Summary introduced preconditions, postconditions, and invariants.
Important in the specification and correctness verification of our designs.
Not part of the language per se, we include them in comments.
May 2004
NH-Chapter4

79. Summary
Client of a method responsible for making sure that all method preconditions are satisfied before invoking method.
Method will work correctly only if preconditions are satisfied.
Preconditions are documented in a require clause of method specification.
May 2004
NH-Chapter4

80. Summary
Method implementor is responsible for making sure that all postconditions are satisfied when method completes.
Postconditions documented in an “ensure clause” of method specification.
May 2004
NH-Chapter4

81. Summary Invariants are conditions that always hold.
Class invariants are conditions that are always true of all instances of a class.
A class instance is a consistent and coherent model of whatever entity the class represents if class invariants hold.
May 2004
NH-Chapter4