chapter 6 boolean variables & nested loops

Chapter 6Boolean Variables & Nested Loops

Section 1 - Review of Logical & Relational Operators

Section 2 - Simple & Compound Boolean Expressions

Section 3 - Truth Tables

Section 4 - String Methods: trim, length, & compareTo

Section 5 - Boolean Variables

Section 6 - Nested For and While Loops

Section 7 - Software Systems

Go

Go

Go

Go

Go

Go

1

Go

Chapter 6 Section 1

Review of Logical and Relational Operators

2

6.1 Logical Operators

Do not place a space between the operators that use two symbols … && and | |

Logical operators are used with if, while, and for statements to control the order of execution.

Logical Operators allow us to modify simple boolean expressions or combine simple boolean expressions into compound ones. These are the three logical operators:

Operator Relationship

! Not

&& And

| | Or

3

6.1 Relational Operators

Do not place a space between the operators that use two symbols … >= <= == or !=

Relational operators are used to form simple Boolean Expressions. Here are the six relational operators:

Operator Relationship

== equal to

!= not equal to

< less than

<= less than or equal to

> greater than

>= greater than or equal to

4

6.1 Precedence Rules for Java Operators

5

Operator Symbol Precedence Level Association

Parentheses ( ) 1 ---------

Method Selector . 2 left to right

Unary Minus - 3 ---------

Unary Plus + 3 ---------

Not ! 3 ---------

Construction new 3 right to left

Casting (int)

(double)

3 right to left

Division / 4 left to right

Multiplication * 4 left to right

Mod or Remainder % 4 left to right

Subtraction - 5 left to right

Addition + 5 left to right

Relational Operators == != < <= > >= 6 ---------

And && 8 left to right

Or | | 9 left to right

Assignment = += -= *= /= %= 10 right to left

Chapter 6 Section 2

Review of Simple and CompoundBoolean Expressions

6

6.2 Simple Boolean Conditions

The ! (“NOT”) operator can be applied to a simple boolean condition or a boolean variable. Here it is applied to a simple boolean expression:

if ( ! (grade > 59) ) System.out.println(“Your grade is an F”);

When applied to a boolean variable or expression, ! changes the overall value to the opposite value.

In the boolean expression above, if grade > 59 evaluates to true,then ! (grade > 59) evaluates to false.

In the boolean expression above, if grade > 59 evaluates to false,then ! (grade > 59) evaluates to true.

7

6.2 Compound Boolean Expressions

The && and || operators are used to form compound boolean expressions.

&

&

(

r

e

f

e

r

r

e

d

t

o

a

s

“

A

N

D

”

)

|

|

(

r

e

f

e

r

r

e

d

t

o

a

s

“

O

R

”

)

We have looked at these examples before:

if (grade >= 90 && grade <= 100)System.out.println (“Your grade is A”);

if (grade < 0 | | grade > 100)System.out.println (“Grade not possible.”);

8

6.2 Extended Ifs withSimple Boolean Expressions

if (testAverage >= 60)

System.out.print(“Grade is D. ”);

else if (testAverage >= 70)

System.out.print(“Grade is C. ”);


System.out.print(“Grade is B. ”);


System.out.print(“Grade is A. ”);

else

System.out.print(“Grade is F. ”);

The order of this extended if statement is problematic because if testAverage holds the value 93, then “Grade is D.” will be printed.

If we change the conditions of the extended-if so that it contains compound boolean expressions, then the order of the branches doesn’t matter and we can guarantee the accuracy of an extended if.

9

6.2 Extended if Statementswith compound boolean expressions

Here is the rewritten extended-if where the order of the branches doesn’t matter, because compound boolean expressions are used in the test conditions.

if (testAverage >= 70 && testAverage < 80)


else if (testAverage >= 80 && testAverage < 90)


else if (testAverage >= 90 && testAverage <= 100 )




else


However, having an un-logical order to the branches as seen here makes the code less readable and more difficult to verify.

10

6.2 Extended if Statementswith compound boolean expressions

Here is the rewritten extended-if where the order of the branches doesn’t matter, because compound boolean expressions are used in the test conditions.

if (testAverage >= 90 && testAverage <= 100)








else


This order is much more logical and adds to the readability of the code.

11

Chapter 6 Section 3

Truth Tables

12

6.3 Truth TablesTruth tables are essential tools for helping us verify the accuracy of

logical expressions, whether they are simple or compound.

For compound boolean expressions involving logical operators, truth

tables show how the value of the overall expression depends on the

values of the operands. Here, the operands are A and B.

• With two operands we must consider all four possible

combinations of values that A and B can have to know what the

expression A && B will evaluate to.

Here is a truth table that shows the results of evaluating A && B.

13

6.3 Truth Table for A && B

The truth table shows you the following results:

If A is true and B is true, then A && B evaluates to true.

If A is true and B is false, then A && B evaluates to false.

If A is false and B is true, then A && B evaluates to false.

If A is false and B is false, then A && B evaluates to false.

Notice that for A && B to evaluate to true, both and A and B must be true individually.

Two operands, A and B. Four possible outcomes for A && B depending on the four possible combinations of true and false. The operands A or B can be simple boolean expressions, like x > 0.

14

6.3 Truth Table for A && BHere is why this is important. You can assume that A and B are simple boolean expressions like:

A is grade >= 90 and B is grade <= 100

You could then use a truth table to verify the results of an if condition like:

if (grade >= 90 && grade <= 100) when grade holds the value 95.

This helps verify that the code is correct when various values are tested.15

6.3 Truth Table for A || B


If A is true and B is true, then A || B evaluates to true.

If A is true and B is false, then A || B evaluates to true.

If A is false and B is true, then A || B evaluates to true.

If A is false and B is false, then A || B evaluates to false.

Notice that A || B is false, only when both A and B are individually false.

Two operands, A and B. Four possible outcomes for A || B depending on the four possible combinations of true and false.

16

6.3 Truth Table for ! A


If A is true, then ! A evaluates to false.

If A is false, then ! A evaluates to true.

One operand, A. Two possible outcomes for ! A depending on the two possible values of true and false.

17

6.3 Possible Combinations in Truth Tables

If there are n operands, then there are 2n combinations of true and

false.

So if there is one operand (like the expression ! A) , there are two

possible values of true and false … 21 = 2.

If there are 2 operands (like A && B) , there are 4 possible

combinations of true and false, and there are 4 possible results …

22 = 4.

If there are 3 operands (like A && B && C), there are 8 possible


23 = 8.

If there are 4 operands (like A || B || C || D), there are 16 possible


24 = 16. 18

6.3 Short-Circuit Evaluation using &&

• In Java, the JVM may know the result of a compound Boolean expression before evaluating all of its parts. Most compilers and systems allow this and will stop evaluation as soon as the result is known. This is called short-circuit evaluation.

• If the first operand A is false and the second operand B is true as in

if( A && B ) …

then the JVM knows the entire condition is false once it sees the first operand is false because && is being used and Java knows that both operands must be true for the entire expression to be true. So the second operand B is not examined at all!

19

6.3 Short-Circuit Evaluation using ||

• For the OR operator ||, if the first operand A is true and the second

operand B is false as in

if( A || B ) …

then the JVM knows the entire condition is true once it sees the

first operand is true because the OR operator || is being used and

Java knows that only one operand must be true for the entire

expression to be true. So the second operand is not examined at

all.

20

6.3 Utilizing Short-Circuit ProtectionsThis code takes advantage of short-circuit evaluation:

Scanner reader = new Scanner(System.in);

int count, sum;

System.out.print(“Enter the count: ”);

count = reader.nextInt();

System.out.print(“Enter the sum: ”);

sum = reader.nextInt();

if (count > 0 && sum/count > 10) // count > 0 must be first for this to work!

System.out.println(“average > 10”);

else

System.out.println(“count = 0 or average <= 10”);

Note: if count is <= 0, the second part of the boolean expression is NOT evaluated and in particular, if count was 0, then the expression is protected against division by zero.

21

6.3 DeMorgan’s Law

DeMorgan’s Law helps define some useful Boolean equivalences.

For instance, the following pairs of Boolean expressions are

equivalent as truth tables readily confirm. The first two are what

are called DeMorgan’s Law.

! (A || B) equivalent to !A && !B

! (A && B) equivalent to !A || !B

A || (B && C) equivalent to (A || B) && (A || C)

A && (B || C) equivalent to (A && B) || (A && C)

22

You only need to remember these two.

6.3 Avoid Complicated Logic

Its best to avoid complicated logical expressions, because they

can be difficult to prove even with a truth table. For example:

if (A || B && C) or if (A && B || C)

however you might need to use logic that says that four

different things must be true before a segment of code is

executed or any of four different things must be false

before a segment of code is executed. You completed

code like this in the program RectangleDrawer.

if (x < 0 || y < 0 || width < 1 || height < 1)

JOptionPane.showMessageDialog(“null”, “You entered …

23

Chapter 6 Section 4

The String Methodstrim(), length(), and compareTo()

24

6.4 The String Method trim()The String class has a method named trim. When a trim message is sent to a string, a new string that contains no leading or trailing blank spaces is returned.

Example:

System.out.print(“Enter a name: ”);

String name = reader.nextLine();

// if the following is entered from the keyboard: “ Jill ”

// then if we printed it out with …

System.out.println(name);

we would see in the output window …

“ Jill ”

However, (see next slide) ….

25

6.4 The String Method trim()

If the code was …



// and again we enter from the keyboard: “ Jill ”

// and then we use the following lines of code:

name = name.trim(); // trim the value in name and restore in name

System.out.println(name);

then we would see in the output window …

“Jill”

Again, when we call name.trim(); the String value in name is trimmed and a new String value is created and returned. By restoring the new value that is returned back into name, then the old value in name is overwritten (deleted). 26

6.4 The String Method length()

We learned earlier this year that the length ( ) method returns the number of characters in a String object. Example:



int length = name.length();

System.out.println(length);

If nothing is entered from the keyboard, not even a blank space, and the return/enter key is pressed, then the variable length would hold the value zero.

Therefore, we can also stop a while ( ! done ) loop if we use an if statement to test whether length holds the value zero as follows:

if (name.length() == 0)

done = true;27

6.4 The String Method compareTo()int compareTo (String other) <--- from the Java APIThe string method compareTo can be used to check to see if the contents of two String objects are equal, in other words to see if they contain exactly the same characters. Example:


if ( name.compareTo(“Bill”) == 0)

System.out.println(“The names are equal.”);

else

System.out.println(“The names are NOT equal.”);

If “Bill” is entered from the keyboard, then obviously the output will be:

“The names are equal.”

You cannot use: if ( name == “Bill” )

You cannot use the == operator to see if two strings contain exactly the same characters. == checks to see if two string variables point at the same string object, not that the contents of the two strings are equivalent. 28

6.4 Using compareTo() to Check Inequality

You can also test to see if two strings are unequal by using != as

follows:


if ( name.compareTo(“Bill”) != 0)

System.out.println(“The name entered is not Bill.”);

else

System.out.println(“The name is Bill.”);

You can see what the output would be depending on what is entered.

29

Chapter 6 Section 5

Boolean Variables

30

6.5 Boolean Variables• Boolean variables can hold a value of true or false.• A boolean is a primitive data type like int, double, or char.

Example:

boolean startGame = true;

if ( startGame ) // there is no reason to use (startGame == true)

{ // but you can… code that sets up and starts the game

}

Java will simply inspect the boolean value inside startGame and

decide whether to run the code in the if branch based on its value.

31

6.5 Unintended Boolean Assignments

It is easy to make the mistake of using = when you mean ==. This is another reason why you should NOT use …

if (startGame == true)

because if you accidentally coded …

if (startGame = true) // this assigns true to the variable startGame

When startGame holds the value false, then you have just given

startGame the value true when you didn’t want to. This would give

erroneous results in a program where you don’t want to execute

the lines of code in the if statement when startGame is false.

32

Eclipse and other compilers will not show a syntax or compile error when you do this!

What is important to realize is that if (startGame = true) doesn’t give a syntax error in Java. Java lets you do this for boolean variables but not for other variables. See the demo program for this.

6.5 Boolean Variable Use Exampleboolean done = false; int sum = 0;// note that since done is false … ! false equals true and the loop runswhile (! done){ System.out.print(“Enter a value to sum: ”); int x = reader.nextInt(); sum += x;

reader.nextLine(); // consume newline characterSystem.out.print (“Type Y to continue or N to stop (Y/N): ”);String ans = reader.nextLine();if ( ! (ans.compareTo(“Y”) == 0) ) // if ans is not equal to Y stop.

done = true; // while (! true) will stop the loop since ! true = false

}Note: when checking to see if two strings are equal, we can’t use ==.

We must call the compareTo() method of the String class. 33

6.5 Compound Boolean Example

Assume factory company XYZ gives two tests to prospective employees to see if they are qualified for any of three levels of positions. The company has jobs available in these areas: managerial, supervisory, and line worker.

For a person to qualify for a management level position, they must score above 90 on both tests.

For a person to qualify for a supervisory level position, they must score above 90 on at least one of the tests.

For a person to qualify for a line worker level position, they must score above 70 on at least one of the tests and they must not score below 50 on either one of the tests.

34


If score1 and score2 are two variables that hold the results of the two

tests for a prospective employee, then how could we write the code

using an if statement to properly test the values of both scores so it

can be determined what positions they are qualified for?

35


If score1 and score2 are two variables that hold the results of the two

tests for a prospective employee, then how could we write the code

using an if statement to properly test the values of both scores so it

can be determined what positions they are qualified for?

if ( score1 >= 90 && score2 >= 90)System.out.println(“Qualified to be a Manager.”);

if ( score1 >= 90 || score2 >= 90)System.out.println(“Qualified to be a Supervisor.”);

if ( (score1 >= 70 || score2 >= 70) && ! (score1 < 50 || score2 < 50))System.out.println(“Qualified to be a Line Worker.”);

36

6.5 Priority of Logical Operators

You can use parentheses with complex expressions as seen on the

last slide. Obviously, expressions in parentheses are evaluated

first.

In the expression below what is executed first?

the && or the ! ???

if ( (score1 >= 70 || score2 >= 70) && ! (score1 < 50 || score2 < 50))

System.out.println(“Qualified to be a Line Worker.”);

37

6.5 Priority of Logical Operators

You can use parentheses with complex expressions as seen

previously. Obviously, expressions in parentheses are evaluated

first.

In the expression below what is executed first?

the && or the ! ??? Answer: the ! (Not)



38

6.5 Code Without Boolean VariablesScanner reader = new Scanner (System.in);

System.out.print(“Enter the first test score: ”);

int score1 = reader.nextInt();

System.out.print(“Enter the second test score: ”);

int score2 = reader.nextInt();

if ( score1 >= 90 && score2 >= 90)

System.out.println(“Qualified to be a Manager.”);

if ( score1 >= 90 || score2 >= 90)

System.out.println(“Qualified to be a Supervisor.”);



39

So let’s review the code again and see how it might be made better by using boolean variables.

6.5 Code Without Boolean VariablesThe last if statement on the previous slide allows us to give a great example of DeMorgan’s Law. The final part of the boolean conditionbelow ….



! (score1 < 50 || score2 < 50))

can also be written as …

(score1 >= 50 && score2 >= 50))

40

6.5 Code With Boolean Variables

By using boolean variables, we can make the code much

easier to read and understand, plus the variables may be

used later on in different lines of code for other purposes if

desired.

However, it requires a little more coding. We need to declare some boolean variables and then give them values.

(See next two slides)

41


boolean bothHigh, atLeastOneHigh,

atLeastOneModerate, noLow;

….. // input code as before

bothHigh = (score1 >= 90 && score2 >= 90);

atLeastOneHigh = (score1 >= 90 || score2 >= 90);

atLeastOneModerate = (score1 >= 70 || score2 >= 70);

noLow = ! (score1 < 50 || score2 < 50);

Any of the expressions on the right can be changed if necessary

without changing any other code and the program will work as

intended. For example, we might want to change the 50s to 60, the 70s

to 80, and the 90s to 95. Now let’s substitute on the next slide 42


Look how nice and readable the code becomes when we use the boolean variables.

if (bothHigh)

System.out.println(“Qualified to be a Manager.”);

if (atLeastOneHigh )

System.out.println(“Qualified to be a Supervisor.”);

if (atLeastOneModerate && noLow )

System.out.println(“Qualified to be a Clerk.”);

43

6.5 Second Example of Boolean VariablesString day = reader.nextLine();

boolean weekday = day.compareTo(“Monday”) == 0 ||

day.compareTo(“Tuesday”) == 0 ||

day.compareTo(“Wednesday”) == 0 ||

day.compareTo(“Thursday”) == 0 ||

day.compareTo(“Friday”) == 0;

if (weekday )

System.out.println(“The day is a weekday”);

Code similar to this will be used on the Birthday Month program.

44

6.5 Precedence Rules for Logical Operators

• Don’t forget the precedence rules for Logical Operators

• ! has the highest precedence & the same precedence

as the other unary operators plus and minus … + -.

• && and || only have higher precedence than the

assignment operators.

• && has higher precedence than ||.

45

6.5 Precedence Rules for Java Operators

46

Operator Symbol Precedence Level Association

Parentheses ( ) 1 ---------

Method Selector . 2 left to right

Unary Minus - 3 ---------

Unary Plus + 3 ---------

Not ! 3 ---------

Construction new 3 right to left

Casting (int)

(double)

3 right to left

Division / 4 left to right

Multiplication * 4 left to right

Mod or Remainder % 4 left to right

Subtraction - 5 left to right

Addition + 5 left to right

Relational Operators == != < <= > >= 6 ---------

And && 8 left to right

Or | | 9 left to right

Assignment = += -= *= /= %= 10 right to left

6.5 Invalid Conjunction Code

Don’t forget … in algebra, we might write a conjunction as:

0 < x < 20 but we cannot do this in Java

We cannot do that in Java, C++, or most other languages. We must write a compound boolean expression as follows:

(x > 0) && (x < 20)

Note the convention is to place x first in both simple boolean expressions. You should practice doing it this way.

47

6.5 Using Boolean Variables to Control LoopsNotice how the boolean variable done is used to start and end the loop appropriately. This loop continues until the user enters an 8 letter word.

boolean done = false;while ( ! done ){ System.out.print("Enter a word that you think has 8 letters: "); String word = reader.nextLine();

if (word.length() == 8) { System.out.println("The word " + word + " has 8 letters in it. This loop is over."); done = true; } else { System.out.println("The word " + word + " does NOT have 8 letters in it."); System.out.println(); }} 48

Chapter 6 Section 6

Nested For and While Loops

49

6.6 Using Loop Control Variables i and j

It has been traditional for over 50 years to use i, j, and k as loop

control variables. This stems from the fact that programmers

might have more than one loop in a program and you couldn’t use

a variable multiple times like modern languages. So

programmers would always use i for their first loop control

variable, j for their second loop lcv, and k for their third loop lcv,

etc. They also liked using one letter loop control variables,

because it cut down on typing, especially when punch cards were

used.

It turns out we will use I and j for loop control variables when we have

nested loops. You’ll see shortly.

50

6.6 Nested Loop StructuresMany problems can be solved by placing one loop inside of another

loop.

If we place one loop inside of another loop, then we call it a nested loop structure.

How could we write a nested for loop structure that would print the following numbers in rows and columns as seen here using a printf statement:

1 2 3 4 5

1 2 3 4 5

1 2 3 4 5

1 2 3 4 5

51

6.6 Nested Loop Example & Output

We could use this code:

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

for (int j = 1; j <= 5; j++){

System.out.printf("%5d", j);}System.out.println();

}

Notice that the outside loop runs four times and the inside loop runs five times.

Observing the output, you notice there are four rows and five columns.

So it should be evident that the outside loop controls the number of rows and the inside loop controls the number of columns.

So since the outside loop runs four times … there are 4 rows. Since the inside loop runs five times … there are 5 columns.

A crucial element to making this print in rows and columns is the System.out.println(); statement after the inside loop! It can’t be in the printf statement.

1 2 3 4 5

1 2 3 4 5

1 2 3 4 5

1 2 3 4 5

52

6.6 Nested Loop Example & Output

Think about the values of i and j as the loop runs.

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

for (int j = 1; j <= 5; j++){

System.out.printf("%5d", j);}System.out.println();

}

When the outside loop runs the first time when i is 1, the inner loop will run three times first when j = 1, then j = 2, and then j = 3.

When the outside loop runs the second time when i is 2, the inner loop will run three times with j = 1, j = 2, and then j = 3.

When the outside loop runs the third time when i is 3, the inner loop will run three times with j = 1, j = 2, and then j = 3.

When the outside loop runs the fourth time when i is 4, the inner loop will run three times with j = 1, j = 2, and then j = 3.

1 2 3 4 5

1 2 3 4 5

1 2 3 4 5

1 2 3 4 5

53

6.6 Nested Loop Example 2Here is a second example of a nested loop structure:

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

for (int j = 1; j <= 3; j++){

System.out.printf("%5d", i);}System.out.println();

}

1 1 1 2 2 2 3 3 3 4 4 4 5 5 5 6 6 6

54

6.6 Nested Loop Example 3Here is a third example of a nested loop structure:

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

for (int j = 1; j <= 8; j++){

System.out.printf("%5d", i + j);}System.out.println();

}

2 3 4 5 6 7 8 9

3 4 5 6 7 8 9 10

4 5 6 7 8 9 10 11

5 6 7 8 9 10 11 12

6 7 8 9 10 11 12 1355

6.6 Nested Loop Example 4Here is a fourth example of a nested loop structure:

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

for (int j = 1; j <= 3; j++){

System.out.printf("%5d", 2 * i + j);}System.out.println();

}

3 4 5

5 6 7

7 8 9

9 10 11

56

6.6 Triangular Nested Loop Example 1This is a triangular nested loop structure, because of the use of the

outside loop control variable i in the inside loop header.

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

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

System.out.print('*'); }System.out.println();

}

**********

Notice the use of j <= i in the nested loop and a printf is not used.

57

6.6 Triangular Nested Loop Example 2Here is a second example of a triangular nested loop structure.

Notice the extended if needed to control the formatting before the inside loop.

for(int lines = 1; lines <= 4; lines++){

// use a field width of 5 - lines to right justify a blank space if (lines == 1)

System.out.printf("%4s", " "); // 5 - 1 = 4 else if (lines == 2)



System.out.printf("%1s", " "); // 5 - 4 = 1

for(int stars = 1; stars <= 2 * lines - 1; stars++)System.out.print ('*');

System.out.println();}

* *** ***** *******

58

6.6 Testing Loops• Loops increase the difficulty of testing, because

– They often do not iterate a fixed number of times– We need to design test data to cover situations where the loop

iterates:• zero times, one time, and multiple times

Whether there is just one loop or a nested loop structure, we need to

be careful how we design our loops and then some testing should

be done.

This means that when checking the design of a loop either by

reviewing the code or running test data, you should check the

following:l entry conditions of the loopl exit conditions of the loopl The number of loop iterations

59

6.6 Printing Proper Divisors

How can we print all of the proper divisors of a number? A positive

proper divisor is a positive divisor of an integer, excluding itself.

For example: 1, 2, and 3 are positive proper divisors of 6, but

6 itself is not.

System.out.print(“Enter a positive integer: ”);

int n = reader.nextInt();

for (int divisor = 1; divisor < n; divisor++)

{

if ( n % divisor == 0)

System.out.println( divisor);

}

You need to stop and think about the kind of test data you need to use to fully test your code. What integers can be entered for n so that the loop will run 0, 1, and multiple times?

Remember n is not considered a proper divisor of itself.

60

6.6 Nested Loops with Boolean Variables It is possible to control nested while loops that are controlled by boolean variables. You can see the overall design here, but a full example is given you in the LoopsWithBooleanVarsDemo program.

boolean quit = false;while ( ! quit ){ System.out.println (”Welcome to the Guessing Game."); boolean done = false; while ( ! done ) { … code for game that eventually sets done to true }

System.out.print("Enter \"quit\" to quit this game or \"no\" to continue: "); String answer = reader.nextLine(); if (answer.compareTo ("quit") == 0) quit = true;

} // end of while ( ! quit) loop

61

6.6 Loop Verification

In designing and implementing loops, it is the responsibility of a

programmer to verify that a loop will do what it is suppose

to do.

In other words, a programmer should provide loop verification

by making statements about a loop that should be true

when a loop is entered and when it is exited. Also, other

statements can be made about how a loop works.

62

6.6 Input & Output Assertions

You are expected to know what an input assertion and output assertion is for the AP exam. These terms refer to loop verification:

1. Input assertions state what should be true before a loop is entered.

2. Output assertions state what should be true when a loop is exited.

63

6.6 Loop Variants & InvariantsTwo other terms are:

1. A Loop invariant is an assertion that expresses a

relationship (between variables) that remain constant

throughout all iterations of a loop. In other words, it is a

statement that is true both before the loop is entered

and after each iteration of the loop.

2. A Loop variant is an assertion whose truth changes

between the first and final execution of the loop. The

loop variant expression should be stated in such a way

that it guarantees the loop is exited.

64

Chapter 6 Section 7

Software Systems

65

6.7 What are Software Systems?

• In the real world, software systems are large programs that

are designed and maintained by a group of programmers,

not a single individual.

• After the design phase, a team of programmers are

assigned various components to implement for a system

being created because they would be unable to write all of

the code by themselves. So a system is made up of

software components.

66

6.7 Information Hiding

• The specifications for a software component contain the

name of the class and the name of the methods, plus any

other vital information needed to be able to call the

methods.

• If a programmer adheres strictly to the specifications, we

don’t care how the code is written just so it doesn’t contain

compile-time or logic errors. We trust that whoever wrote

the code made it efficient.

67

6.7 The Quality of Software Systems

• There are several measures of software quality, such as

readability, maintainability, robustness and

correctness.

• Overall a Software System must be reliable meaning

that it should contain all of the above characteristics to a

high degree, but it is only reliable if the model designed and

built by the programmers represents the software that was

requested to be made.

68

6.7 Readability of Program Code

• Readability refers to the ability of any programmer to be

able to easily read and understand the code in a program.

Readability is dependent on choosing good method and

variable names, as well as, indentation and spacing. The

method and variable names should be self-describing.

69

6.7 Maintainability of Program Code

• Maintainability refers to the ability of programmers to be

able to easily maintain the code in a program. This means it

should be easy to update the code by adding or deleting

portions of it without significantly changing the overall

design.

70

6.7 Robustness of Program Code

• A program should be robust.

• A Robust program tolerates errors in user inputs and

recovers gracefully without halting the program. (You will

learn some of the ways to do this in different ways in the near

future.)

• The best and easiest way to write robust programs is to

check user inputs immediately on entry and reject invalid

user inputs by giving them feedback through error

messages.

71

6.7 Correctness of Program Code

• Finally, Correctness refers to whether the code of a

program is written correctly without any logic errors and

does the code implement the functionality of the program the

way that it was intended.

72

chapter 6 boolean variables & nested loops

Documents