Software Engineering for Students A Programming Approach

186 Chapter 14 ■ The basics
>
}
}
statement(s)
if (exitCondition) break here;
statement(s)
In the second example above, control will be transferred out of both while loops
when exitCondition is true. Note how the outer while loop is labeled here: and
how this label is used by the if statement to specify that control is to be transferred to
the end of the while loop (not the beginning) when exitCondition is satisfied.
SELF-TEST QUESTION
14.2 Sketch out the code for a method to search an array of integers to find
some desired integer. Write two versions – one using the break mechanism
and one without break.
The languages C, C++, Ada and Java provide a mechanism such as the above for
breaking out in the middle of loops.
There is some controversy about using break statements. Some people argue that it
is simply too much like the notorious goto statement. There is a difference, however,
because break can only be used to break out of a loop, not enter into a loop. Neither
can break be used to break out of an if statement. Thus it might be argued that
break is a goto that is under control.
Handling errors or exceptional situations is a common programming situation. In
the past, such an eventuality was handled using the goto statement. Nowadays features
are built in to programming languages to facilitate the more elegant handling of such
situations. We discuss the handling of exceptions in Chapter 17.
14.8 ● Methods
Procedural or algorithmic abstraction is one of the most powerful tools in the programmer’s
arsenal. When designing a program, we abstract what should be done
before we specify how it should be done. Before OOP, program designs evolved as
layers of procedural abstractions, each layer specifying more detail than the layer
above. Procedural abstractions in programming languages, such as procedures and
functions, allow the layered design of a program to be accurately reflected in the
structure of the program text. Even in relatively small programs, the ability to factor
a program into small, functional modules is essential; factoring increases the readability
and maintainability of programs. What does the software engineer require
from a language in terms of support for procedural abstraction? We suggest the