Transcript Document

Chapter 8
High-Level Programming
Languages
Chapter Goals
• Describe the translation process and
distinguish between assembly, compilation,
interpretation, and execution
• Name four distinct programming
paradigms and name a language
characteristic of each
• Describe the following constructs: stream
input and output, selection, looping, and
subprograms
2
Chapter Goals
• Construct Boolean expressions and
describe how they are used to alter the
flow of control of an algorithm
• Define the concepts of a data type and
strong typing
• Explain the concept of a parameter and
distinguish between value and reference
parameters
3
Chapter Goals
• Describe two composite data-structuring
mechanisms
• Name, describe, and give examples of the
three essential ingredients of an objectoriented language
4
Compilers
High-level language
A language that provides a richer (more
English like) set of instructions
Compiler
A program that translates a high-level
language program into machine code
5
Compilers
Figure 8.1 Compilation process
6
How does this differ from
the assembly process?
Interpreters
Interpreter
A translating program that translates and executes
the statements in sequence
– Assembler or compiler produce machine code as
output, which is then executed in a separate step
– An interpreter translates a statement and then
immediately executes the statement
– Interpreters can be viewed as simulators
7
Java
• Introduced in 1996 and became instantly
popular
• Portability was of primary importance
• Java is compiled into a standard machine
language called Bytecode
• A software interpreter called the JVM
(Java Virtual Machine) takes the Bytecode
program and executes it
8
Portability
Portability
The ability of a program to be run on different machines
Compiler portability
A program in a standardized language can be compiled
and run on any machine that has the appropriate compiler
Bytecode portability
A program translated into Bytecode can be run on
any machine that has a JVM
Do you understand the difference?
9
Portability
Figure 8.2
Portability
provided by
standardized
languages versus
interpretation by
10
Bytecode
Portability
Figure 8.2
Portability
provided by
standardized
languages versus
interpretation by
11
Bytecode
Programming Language Paradigms
Imperative or procedural model
– Program describes the processing
– FORTRAN, COBOL, BASIC, C, Pascal,
Ada, and C++
Functional model
– Program is written terms of mathematical
functions
– LISP, Scheme (a derivative of LISP), and ML
12
Programming Language Paradigms
Logic model
– Program consists of facts about objects and rules that
question the relationships among facts
– PROLOG
Object-oriented model
– Program consists of a set of objects and the
interactions among the objects
– Smalltalk and Simula
– C++ is as an imperative language with some objectoriented features
– Java is an object-oriented language with some
imperative features
13
Programming Language Paradigms
We examine procedural and object-oriented
languages in the rest of this chapter by looking at
the functionality provided in these languages
We give examples in different languages to show
how syntax used to provide the functionality
14
Functionality of Imperative
Languages
Sequence
Executing statements in sequence until an instruction is
encountered that changes this sequencing
Selection
Deciding which action to take
Iteration (looping)
Repeating an action
Do these concepts sound familiar?
Let's review them.
15
Boolean Expressions
Boolean expression
A sequence of identifiers, separated by compatible
operators, that evaluates to true or false
A Boolean expression can be
– A Boolean variable
– An arithmetic expression followed by a relational
operator followed by an arithmetic expression
– A Boolean expression followed by a Boolean
operator followed by a Boolean expression
16
Boolean Expressions
Variable
A location in memory that is referenced by
an identifier that contains a data value
Thus, a Boolean variable is a location in
memory that can contain either true or false
17
Boolean Expressions
Remember the relational operators?
List them!
18
Strong Typing
Data type
A description of the set of values and the basic set
of operations that can be applied to values of the
type
Strong typing
The requirement that only a value of the proper
type can be stored into a variable
19
Data Types
Integer numbers
Real numbers
Characters
Boolean values
Strings
20
Give examples
of
each
Integers
What determines the range of an integer
value?
Is the range of an integer value the same in
all languages?
What operations can be applied to integers?
21
Reals
How are real values like integer values?
How do real values differ from integer values?
22
Characters
Do you remember
ASCII?
Extended ASCII?
UNICODE?
How many characters in Extended ASCII?
How many characters in UNICODE?
What does a relational operator between two
characters mean?
23
Boolean and Strings
What values can a Boolean variable be?
For what are Boolean expressions used?
What is a string?
What operations can be applied to strings?
24
Declarations
Declaration
A statement that associates an identifier with a
variable, an action, or some other entity within
the language that can be given a name; the
programmer can refer to that item by name
Reserved word
A word in a language that has special meaning
Case-sensitive
Uppercase and lowercase letters are considered
the same
25
Declaration Example
Assignment statement
Assignment statement
An action statement (not a declaration) that says to
evaluate the expression on the right-hand side of
the symbol and store that value into the place
named on the left-hand side
Named constant
A location in memory, referenced by an identifier,
that contains a data value that cannot be changed
Remember?
27
Input/Output Structures
Pseudocode algorithms used the expressions
Read or Get and Write or Print
High-level languages view input data as a stream
of characters divided into lines
Key to the processing
The data type determines how characters are to
be converted to a bit pattern (input) and how a bit
pattern is to be converted to characters (output)
28
Input/Output Structures
Read name, age, hourlyWage
name is a string;
age is an integer;
hourlyWage is a real
The data must be a string, an integer, and a
real in that order.
29
Control Structures
Control structure
An instruction that determines the order in
which other instructions in a program are
executed
Can you name the ones we defined in the
functionality of pseudocode?
30
Selection Statements
Figure 8.3 Flow of control of
if statement
31
Selection Statements
The if statement allows the program to test the state of the
program variables using a Boolean expression
32
Blocks
Note
the
symbols
used to
indicate
blocks
in each
language
33
Cascading Ifs
If (temperature > 90)
Write "Texas weather: wear shorts"
Else If (temperature > 50)
Write "A little chilly: wear a light jacket"
Else If (temperature > 32)
Write "Philadelphia weather: wear a heavy coat"
Else
Write "Stay inside"
Why does this work correctly?
34
Looping Statements
Figure 8.4
Flow of control of while statement
35
Looping Statements
A count-controlled loop
Set sum to 0
Set count to 1
While (count <= limit)
Read number
Set sum to sum + number
Increment count
Write "Sum is " + sum
36
Why is it
called a
count-controlled
loop?
Looping Statements
37
Looping Statements
An event-controlled loop
Set sum to 0
Set allPositive to true
While (allPositive)
Read number
If (number > 0)
Set sum to sum + number
Else
Set allPositive to false
Write "Sum is " + sum
38
Why is it
called an
event-conrolled
loop?
What is the
event?
Subprogram Statements
We can give a section of code a name and
use that name as a statement in another
part of the program
When the name is encountered, the
processing in the other part of the program
halts while the named code is executed
Remember?
39
Subprogram Statements
What if the subprogram needs data from the
calling unit?
Parameters
Identifiers listed in parentheses beside the
subprogram declaration; sometimes called formal
parameters
Arguments
Identifiers listed in parentheses on the
subprogram call; sometimes called actual
parameters
40
Subprogram Statements
41Figure 8.5 Subprogram flow of control
Subprogram Statements
42Figure 8.5 Subprogram flow of control
Subprogram Statements
Value parameter
A parameter that expects a copy of its
argument to be passed by the calling unit
Reference parameter
A parameter that expects the address of its
argument to be passed by the calling unit
43
Subprogram Statements
Think of arguments as being placed on a message board
44
Subprogram Statements
45
Recursion
Recursion
The ability of a subprogram to call itself
Base case
The case to which we have an answer
General case
The case that expresses the solution in terms of a
call to itself with a smaller version of the problem
46
Recursion
For example, the factorial of a number is defined
as the number times the product of all the numbers
between itself and 0:
N! = N * (N  1)!
Base case
Factorial(0) = 1 (0! is 1)
General Case
Factorial(N) = N * Factorial(N-1)
47
Asynchronous Processing
Asynchronous processing
Not synchronized with the program's action
– Clicking has become a major form of input
to the computer
– Mouse clicking is not within the sequence
of the program
– A user can click a mouse at any time during
the execution of a program
48
Composite Data Types
Records
A named heterogeneous collection of items
in which individual items are accessed by
name
Arrays
A named homogeneous collection of items
in which an individual item is accessed by its
position (index) within the collection
49
Composite Data Types
Declare Record
50
Composite Data Types
51
Declare record variable
Use record variable
Composite Data Types
An Array
52
Figure 8.8
Array variable
tenThings
accessed
from 0..9
Composite Data Types
Declare Array
53
Composite Data Types
Access an Array
54
Functionality of Object-Oriented
Languages
Remember the definitions from Chapter 6?
Encapsulate
Object class
Object in problem-solving phase
Object in implementation phase
Class in implementation phase
Instantiate
55
Don't worry!
We'll review
these
concepts
Review
Object class (problem-solving phase)
A description of a group of objects with similar
properties and behaviors
Object (problem-solving phase)
An entity or thing that is relevant in the context of a
problem
Instantiate
Create an object from a class
56
Review
Encapsulation
A language feature that enforces information hiding
(second definition)
Class (implementation phase)
A language construct that is a pattern for an object and
provides a mechanism for encapsulating the properties and
actions of the object class
Object (implementation phase)
An instance of a class
57
Review
Remember
the
pattern?
From
problem
to general
description
to class
definition to
program
58
Inheritance and Polymorphism
Inheritance
A construct that fosters reuse by allowing an
application to take an already-tested class and
derive a class from it that inherits the properties
the application needs
Polymorphism
The ability of a language to have duplicate method
names in an inheritance hierarchy and to apply the
method that is appropriate for the object to which
the method is applied
59
Inheritance and Polymorphism
Inheritance and polymorphism work together
How?
They combine to allow the programmer to build
useful hierarchies of classes that can be put into a
library to be reused in different applications
60