PPL Unit-4

OBJECT-ORIENTED
PROGRAMMING
GVP COLLEGE OF ENGINEERING FOR WOMEN 1-1

Topics
• Introduction
• Object-Oriented Programming
• Design Issues for Object-Oriented Languages
• Implementation of Object-Oriented Constructs

Introduction
• Many object-oriented programming (OOP)
languages
– Some support procedural and data-oriented
programming (e.g., Ada 95 and C++)
– Some support functional program (e.g., CLOS)
– Newer languages do not support other
paradigms but use their imperative structures
(e.g., Java and C#)
– Some are pure OOP language (e.g., Smalltalk &
Ruby)

Object-Oriented Programming
• Abstract data types

• Inheritance
– Inheritance is the central theme in OOP and
languages that support it
• Polymorphism

Inheritance
• Productivity increases can come from reuse

– ADTs are difficult to reuse—always need
changes
– All ADTs are independent and at the same level
• Inheritance allows new classes defined in
terms of existing ones, i.e., by allowing
them to inherit common parts
• Inheritance addresses both of the above
concerns--reuse ADTs after minor changes
and define classes in a hierarchy

Object-Oriented Concepts
• ADTs are usually called classes

• Class instances are called objects
• A class that inherits is a derived class or a
subclass
• The class from which another class inherits
is a parent class or superclass
• Subprograms that define operations on
objects are called methods

Object-Oriented Concepts (continued)
• Calls to methods are called messages

• The entire collection of methods of an
object is called its message protocol or
message interface
• Messages have two parts--a method name
and the destination object
• In the simplest case, a class inherits all of
the entities of its parent

• Inheritance can be complicated by access

controls to encapsulated entities
– A class can hide entities from its subclasses
– A class can hide entities from its clients
– A class can also hide entities for its clients while
allowing its subclasses to see them
• Besides inheriting methods as is, a class
can modify an inherited method
– The new one overrides the inherited one
– The method in the parent is overriden

• There are two kinds of variables in a class:

– Class variables - one/class
– Instance variables - one/object
• There are two kinds of methods in a class:
– Class methods – accept messages to the class
– Instance methods – accept messages to objects
• Single vs. Multiple Inheritance
• One disadvantage of inheritance for reuse:
– Creates interdependencies among classes that
complicate maintenance

Dynamic Binding
• A polymorphic variable can be defined in a

class that is able to reference (or point to)
objects of the class and objects of any of its
descendants
• When a class hierarchy includes classes that
override methods and such methods are
called through a polymorphic variable, the
binding to the correct method will be
dynamic
• Allows software systems to be more easily
extended during both development and
maintenance
Dynamic Binding Concepts
• An abstract method is one that does not

include a definition (it only defines a
protocol)
• An abstract class is one that includes at
least one virtual method
• An abstract class cannot be instantiated

Design Issues for OOP Languages
• The Exclusivity of Objects

• Are Subclasses Subtypes?
• Type Checking and Polymorphism
• Single and Multiple Inheritance
• Object Allocation and Deallocation
• Dynamic and Static Binding
• Nested Classes
• Initialization of Objects

The Exclusivity of Objects
• Everything is an object
– Advantage - elegance and purity
– Disadvantage - slow operations on simple objects
• Add objects to a complete typing system
– Advantage - fast operations on simple objects
– Disadvantage - results in a confusing type system (two
kinds of entities)
• Include an imperative-style typing system for
primitives but make everything else objects
– Advantage - fast operations on simple objects and a
relatively small typing system
– Disadvantage - still some confusion because of the two
type systems

Are Subclasses Subtypes?
• Does an “is-a” relationship hold between a

parent class object and an object of the
subclass?
– If a derived class is-a parent class, then objects
of the derived class must behave the same as
the parent class object
• A derived class is a subtype if it has an is-a
relationship with its parent class
– Subclass can only add variables and methods
and override inherited methods in “compatible”
ways

Type Checking and Polymorphism
• Polymorphism may require dynamic type

checking of parameters and the return
value
– Dynamic type checking is costly and delays error
detection
• If overriding methods are restricted to
having the same parameter types and
return type, the checking can be static

Single and Multiple Inheritance
• Multiple inheritance allows a new class to

inherit from two or more classes
• Disadvantages of multiple inheritance:
– Language and implementation complexity (in
part due to name collisions)
– Potential inefficiency - dynamic binding costs
more with multiple inheritance (but not much)
• Advantage:
– Sometimes it is quite convenient and valuable

Allocation and DeAllocation of Objects
• From where are objects allocated?

– If they behave line the ADTs, they can be
allocated from anywhere
• Allocated from the run-time stack
• Explicitly create on the heap (via new)
– If they are all heap-dynamic, references can be
uniform thru a pointer or reference variable
• Simplifies assignment - dereferencing can be
implicit
– If objects are stack dynamic, there is a problem
with regard to subtypes
• Is deallocation explicit or implicit?

Dynamic and Static Binding
• Should all binding of messages to methods

be dynamic?
– If none are, you lose the advantages of dynamic
binding
– If all are, it is inefficient
• Allow the user to specify

Nested Classes
• If a new class is needed by only one class,

there is no reason to define so it can be
seen by other classes
– Can the new class be nested inside the class
that uses it?
– In some cases, the new class is nested inside a
subprogram rather than directly in another class
• Other issues:
– Which facilities of the nesting class should be
visible to the nested class and vice versa

Initialization of Objects
• Are objects initialized to values when they

are created?
– Implicit or explicit initialization
• How are parent class members initialized

when a subclass object is created?

Implementing OO Constructs
• Two interesting and challenging parts

– Storage structures for instance variables
– Dynamic binding of messages to methods

Instance Data Storage
• Class instance records (CIRs) store the state

of an object
– Static (built at compile time)
• If a class has a parent, the subclass
instance variables are added to the parent
CIR
• Because CIR is static, access to all instance
variables is done as it is in records
– Efficient

Dynamic Binding of Methods Calls
• Methods in a class that are statically bound

need not be involved in the CIR; methods
that will be dynamically bound must have
entries in the CIR
– Calls to dynamically bound methods can be
connected to the corresponding code thru a
pointer in the CIR
– The storage structure is sometimes called
virtual method tables (vtable)
– Method calls can be represented as offsets from
the beginning of the vtable

Summary
• OO programming involves three fundamental concepts:

ADTs, inheritance, dynamic binding
• Major design issues: exclusivity of objects, subclasses and
subtypes, type checking and polymorphism, single and
multiple inheritance, dynamic binding, explicit and implicit
de-allocation of objects, and nested classes
• Smalltalk is a pure OOL
• C++ has two distinct type system (hybrid)
• Java is not a hybrid language like C++; it supports only OO
programming
• C# is based on C++ and Java
• Ruby is a new pure OOP language; provides some new ideas
in support for OOP
• JavaScript is not an OOP language but provides interesting
variations
• Implementing OOP involves some new data structures

CONCURRENCY

Topics
• Introduction
• Introduction to Subprogram-Level Concurrency
• Semaphores
• Monitors
• Message Passing
• Ada Support for Concurrency
• Java Threads
• C# Threads
• Statement-Level Concurrency

Introduction
• Concurrency can occur at four levels:

– Machine instruction level
– High-level language statement level
– Unit level
– Program level
• Because there are no language issues in
instruction- and program-level
concurrency, they are not addressed here

Multiprocessor Architectures
• Late 1950s - one general-purpose processor and
one or more special-purpose processors for input
and output operations
• Early 1960s - multiple complete processors, used
for program-level concurrency
• Mid-1960s - multiple partial processors, used for
instruction-level concurrency
• Single-Instruction Multiple-Data (SIMD) machines
• Multiple-Instruction Multiple-Data (MIMD)
machines
– Independent processors that can be synchronized (unit-
level concurrency)

Categories of Concurrency
• A thread of control in a program is the

sequence of program points reached as
control flows through the program
• Categories of Concurrency:
– Physical concurrency - Multiple independent
processors ( multiple threads of control)
– Logical concurrency - The appearance of
physical concurrency is presented by time-
sharing one processor (software can be
designed as if there were multiple threads of
control)
• Coroutines (quasi-concurrency) have a
single thread of control
Motivations for Studying Concurrency
• Involves a different way of designing

software that can be very useful—many
real-world situations involve concurrency
• Multiprocessor computers capable of
physical concurrency are now widely used

Introduction to Subprogram-Level
Concurrency
• A task or process is a program unit that can
be in concurrent execution with other
program units
• Tasks differ from ordinary subprograms in
that:
– A task may be implicitly started
– When a program unit starts the execution of a
task, it is not necessarily suspended
– When a task’s execution is completed, control
may not return to the caller
• Tasks usually work together

Two General Categories of Tasks
• Heavyweight tasks execute in their own

address space
• Lightweight tasks all run in the same
address space – more efficient
• A task is disjoint if it does not
communicate with or affect the execution
of any other task in the program in any way

Task Synchronization
• A mechanism that controls the order in

which tasks execute
• Two kinds of synchronization
– Cooperation synchronization
– Competition synchronization
• Task communication is necessary for
synchronization, provided by:
- Shared nonlocal variables
- Parameters
- Message passing

Kinds of synchronization
• Cooperation: Task A must wait for task B to
complete some specific activity before task
A can continue its execution, e.g., the
producer-consumer problem
• Competition: Two or more tasks must use
some resource that cannot be
simultaneously used, e.g., a shared counter
– Competition is usually provided by mutually
exclusive access (approaches are discussed
later)

Need for Competition Synchronization

Scheduler
• Providing synchronization requires a

mechanism for delaying task execution
• Task execution control is maintained by a
program called the scheduler, which maps
task execution onto available processors

Task Execution States
• New - created but not yet started

• Rready - ready to run but not currently
running (no available processor)
• Running
• Blocked - has been running, but
cannot now continue (usually waiting
for some event to occur)
• Dead - no longer active in any sense

Liveness and Deadlock
• Liveness is a characteristic that a program

unit may or may not have
- In sequential code, it means the unit will
eventually complete its execution
• In a concurrent environment, a task can
easily lose its liveness
• If all tasks in a concurrent environment lose
their liveness, it is called deadlock

Design Issues for Concurrency
• Competition and cooperation
synchronization
• Controlling task scheduling
• How and when tasks start and end
execution
• How and when are tasks created

Methods of Providing Synchronization
• Semaphores
• Monitors
• Message Passing

Semaphores
• Dijkstra - 1965
• A semaphore is a data structure consisting of a
counter and a queue for storing task descriptors
• Semaphores can be used to implement guards on
the code that accesses shared data structures
• Semaphores have only two operations, wait and
release (originally called P and V by Dijkstra)
• Semaphores can be used to provide both
competition and cooperation synchronization

Cooperation Synchronization with
Semaphores
• Example: A shared buffer

• The buffer is implemented as an ADT with
the operations DEPOSIT and FETCH as the
only ways to access the buffer
• Use two semaphores for cooperation:
emptyspots and fullspots
• The semaphore counters are used to store
the numbers of empty spots and full spots
in the buffer

Semaphores (continued)
• DEPOSIT must first check emptyspots to
see if there is room in the buffer
• If there is room, the counter of emptyspots
is decremented and the value is inserted
• If there is no room, the caller is stored in
the queue of emptyspots
• When DEPOSIT is finished, it must
increment the counter of fullspots

Semaphores (continued)
• FETCH must first check fullspots to see if
there is a value
– If there is a full spot, the counter of fullspots
is decremented and the value is removed
– If there are no values in the buffer, the caller
must be placed in the queue of fullspots
– When FETCH is finished, it increments the
counter of emptyspots
• The operations of FETCH and DEPOSIT on
the semaphores are accomplished through
two semaphore operations named wait and
release
Semaphores: Wait Operation
wait(aSemaphore)
if aSemaphore’s counter > 0 then
decrement aSemaphore’s counter
else
put the caller in aSemaphore’s queue
attempt to transfer control to a ready task
-- if the task ready queue is empty,
-- deadlock occurs
end

Semaphores: Release Operation
release(aSemaphore)
if aSemaphore’s queue is empty then
increment aSemaphore’s counter
else
put the calling task in the task ready queue
transfer control to a task from aSemaphore’s queue
end

Producer Code
semaphore fullspots, emptyspots;

fullstops.count = 0;
emptyspots.count = BUFLEN;
task producer;
loop
-- produce VALUE –-
wait (emptyspots); {wait for space}
DEPOSIT(VALUE);
release(fullspots); {increase filled}
end loop;
end producer;

Consumer Code
task consumer;
loop
wait (fullspots);{wait till not empty}}
FETCH(VALUE);
release(emptyspots); {increase empty}
-- consume VALUE –-
end loop;
end consumer;

Competition Synchronization with
Semaphores
• A third semaphore, named access, is used
to control access (competition
synchronization)
– The counter of access will only have the values
0 and 1
– Such a semaphore is called a binary semaphore
• Note that wait and release must be atomic!

Producer Code
semaphore access, fullspots, emptyspots;
access.count = 0;
fullstops.count = 0;
emptyspots.count = BUFLEN;
task producer;
loop
-- produce VALUE –-
wait(emptyspots); {wait for space}
wait(access); {wait for access)
DEPOSIT(VALUE);
release(access); {relinquish access}
release(fullspots); {increase filled}
end loop;
end producer;

Consumer Code
task consumer;
loop
wait(fullspots);{wait till not empty}
wait(access); {wait for access}
FETCH(VALUE);
release(access); {relinquish access}
release(emptyspots); {increase empty}
-- consume VALUE –-
end loop;
end consumer;

Evaluation of Semaphores
• Misuse of semaphores can cause failures in

cooperation synchronization, e.g., the
buffer will overflow if the wait of
fullspots is left out
• Misuse of semaphores can cause failures in
competition synchronization, e.g., the
program will deadlock if the release of
access is left out

Monitors
• Ada, Java, C#
• The idea: encapsulate the shared data and
its operations to restrict access
• A monitor is an abstract data type for
shared data

Competition Synchronization
• Shared data is resident in the monitor

(rather than in the client units)
• All access resident in the monitor
– Monitor implementation guarantee
synchronized access by allowing only one
access at a time
– Calls to monitor procedures are implicitly
queued if the monitor is busy at the time of the
call

Cooperation Synchronization
• Cooperation between processes is still a

programming task
– Programmer must guarantee that a shared
buffer does not experience underflow or
overflow

Evaluation of Monitors
• A better way to provide competition

synchronization than are semaphores
• Semaphores can be used to implement
monitors
• Monitors can be used to implement
semaphores
• Support for cooperation synchronization is
very similar as with semaphores, so it has
the same problems

Message Passing
• Message passing is a general model for
concurrency
– It can model both semaphores and monitors
– It is not just for competition synchronization
• Central idea: task communication is like
seeing a doctor--most of the time she
waits for you or you wait for her, but when
you are both ready, you get together, or
rendezvous

Message Passing Rendezvous
• To support concurrent tasks with message
passing, a language needs:
- A mechanism to allow a task to indicate when it

is willing to accept messages
- A way to remember who is waiting to have its

message accepted and some “fair” way of choosing
the next message
• When a sender task’s message is accepted by a

receiver task, the actual message transmission is
called a rendezvous

Ada Support for Concurrency
• The Ada 83 Message-Passing Model

– Ada tasks have specification and body parts,
like packages; the spec has the interface, which
is the collection of entry points:
task Task_Example is
entry ENTRY_1 (Item : in Integer);
end Task_Example;

Task Body
• The body task describes the action that
takes place when a rendezvous occurs
• A task that sends a message is suspended
while waiting for the message to be
accepted and during the rendezvous
• Entry points in the spec are described with
accept clauses in the body
accept entry_name (formal parameters) do
…
end entry_name

Example of a Task Body
task body Task_Example is
begin
loop
accept Entry_1 (Item: in Float) do
...
end Entry_1;
end loop;
end Task_Example;

Ada Message Passing Semantics
• The task executes to the top of the accept

clause and waits for a message
• During execution of the accept clause, the
sender is suspended
• accept parameters can transmit
information in either or both directions
• Every accept clause has an associated
queue to store waiting messages

Rendezvous Time Lines

Message Passing: Server/Actor Tasks
• A task that has accept clauses, but no

other code is called a server task (the
example above is a server task)
• A task without accept clauses is called an
actor task
– An actor task can send messages to other tasks
– Note: A sender must know the entry name of
the receiver, but not vice versa (asymmetric)

Graphical Representation of a
Rendezvous

Multiple Entry Points
• Tasks can have more than one entry point
– The specification task has an entry clause for
each
– The task body has an accept clause for each
entry clause, placed in a select clause, which
is in a loop

A Task with Multiple Entries
task body Teller is
loop
select
accept Drive_Up(formal params) do
...
end Drive_Up;
...
or
accept Walk_Up(formal params) do
...
end Walk_Up;
...
end select;
end loop;
end Teller;

Semantics of Tasks with Multiple
accept Clauses
• If exactly one entry queue is nonempty, choose a
message from it
• If more than one entry queue is nonempty,
choose one, nondeterministically, from which to
accept a message
• If all are empty, wait
• The construct is often called a selective wait
• Extended accept clause - code following the
clause, but before the next clause
– Executed concurrently with the caller

Message Passing
• Provided by Guarded accept clauses
when not Full(Buffer) =>
accept Deposit (New_Value) do
...
end
• An accept clause with a with a when clause is
either open or closed
– A clause whose guard is true is called open
– A clause whose guard is false is called closed
– A clause without a guard is always open

Semantics of select with Guarded
accept Clauses:
• select first checks the guards on all clauses
• If exactly one is open, its queue is checked for
messages
• If more than one are open, non-deterministically
choose a queue among them to check for messages
• If all are closed, it is a runtime error
• A select clause can include an else clause to
avoid the error
– When the else clause completes, the loop
repeats

Example of a Task with Guarded
accept Clauses
• Note: The station may be out of gas and
there may or may not be a position
available in the garage
task Gas_Station_Attendant is
entry Service_Island (Car : Car_Type);
entry Garage (Car : Car_Type);
end Gas_Station_Attendant;

Example of a Task with Guarded
accept Clauses
task body Gas_Station_Attendant is
begin
loop
select
when Gas_Available =>
accept Service_Island (Car : Car_Type) do
Fill_With_Gas (Car);
end Service_Island;
or
when Garage_Available =>
accept Garage (Car : Car_Type) do
Fix (Car);
end Garage;
else
Sleep;
end select;
end loop;
end Gas_Station_Attendant;

Competition Synchronization with
Message Passing
• Modeling mutually exclusive access to
shared data
• Example--a shared buffer
• Encapsulate the buffer and its operations in
a task
• Competition synchronization is implicit in
the semantics of accept clauses
– Only one accept clause in a task can be active
at any given time

Task Termination
• The execution of a task is completed if
control has reached the end of its code
body
• If a task has created no dependent tasks
and is completed, it is terminated
• If a task has created dependent tasks and is
completed, it is not terminated until all its
dependent tasks are terminated

The terminate Clause
• A terminate clause in a select is just a

terminate statement
• A terminate clause is selected when no
accept clause is open
• When a terminate is selected in a task, the
task is terminated only when its master and
all of the dependents of its master are
either completed or are waiting at a
terminate
• A block or subprogram is not left until all
of its dependent tasks are terminated

Message Passing Priorities
• The priority of any task can be set with the

pragma priority
pragma Priority (expression);
• The priority of a task applies to it only
when it is in the task ready queue

Binary Semaphores
• For situations where the data to which access is to

be controlled is NOT encapsulated in a task
task Binary_Semaphore is
entry Wait;
entry release;
end Binary_Semaphore;
task body Binary_Semaphore is

begin
loop
accept Wait;
accept Release;
end loop;
end Binary_Semaphore;

Concurrency in Ada 95
• Ada 95 includes Ada 83 features for

concurrency, plus two new features
– Protected objects: A more efficient way of
implementing shared data to allow access to a
shared data structure to be done without
rendezvous
– Asynchronous communication

Ada 95: Protected Objects
• A protected object is similar to an abstract
data type
• Access to a protected object is either
through messages passed to entries, as
with a task, or through protected
subprograms
• A protected procedure provides mutually
exclusive read-write access to protected
objects
• A protected function provides concurrent
read-only access to protected objects

Asynchronous Communication
• Provided through asynchronous select

structures
• An asynchronous select has two
triggering alternatives, an entry clause or a
delay
– The entry clause is triggered when sent a
message
– The delay clause is triggered when its time limit
is reached

Evaluation of the Ada
• Message passing model of concurrency is

powerful and general
• Protected objects are a better way to
provide synchronized shared data
• In the absence of distributed processors,
the choice between monitors and tasks with
message passing is somewhat a matter of
taste
• For distributed systems, message passing
is a better model for concurrency

Java Threads
• The concurrent units in Java are methods named
run
– A run method code can be in concurrent execution with
other such methods
– The process in which the run methods execute is called a
thread
Class myThread extends Thread
public void run () {…}
}
…
Thread myTh = new MyThread ();
myTh.start();

Controlling Thread Execution
• The Thread class has several methods to

control the execution of threads
– The yield is a request from the running thread
to voluntarily surrender the processor
– The sleep method can be used by the caller of
the method to block the thread
– The join method is used to force a method to
delay its execution until the run method of
another thread has completed its execution

Thread Priorities
• A thread’s default priority is the same as

the thread that create it
– If main creates a thread, its default priority is
NORM_PRIORITY
• Threads defined two other priority
constants, MAX_PRIORITY and
MIN_PRIORITY
• The priority of a thread can be changed
with the methods setPriority

Competition Synchronization with Java
Threads
• A method that includes the synchronized
modifier disallows any other method from running
on the object while it is in execution
…
public synchronized void deposit( int i) {…}
public synchronized int fetch() {…}
…
• The above two methods are synchronized which
prevents them from interfering with each other
• If only a part of a method must be run without
interference, it can be synchronized thru
synchronized statement
synchronized (expression)
statement

Cooperation Synchronization with Java
Threads
• Cooperation synchronization in Java is
achieved via wait, notify, and notifyAll
methods
– All methods are defined in Object, which is the
root class in Java, so all objects inherit them
• The wait method must be called in a loop
• The notify method is called to tell one
waiting thread that the event it was waiting
has happened
• The notifyAll method awakens all of the
threads on the object’s wait list
Java’s Thread Evaluation
• Java’s support for concurrency is relatively

simple but effective
• Not as powerful as Ada’s tasks

C# Threads
• Loosely based on Java but there are significant

differences
• Basic thread operations
– Any method can run in its own thread
– A thread is created by creating a Thread object
– Creating a thread does not start its concurrent execution;
it must be requested through the Start method
– A thread can be made to wait for another thread to finish
with Join
– A thread can be suspended with Sleep
– A thread can be terminated with Abort

Synchronizing Threads
• Three ways to synchronize C# threads

– The Interlocked class
• Used when the only operations that need to be
synchronized are incrementing or decrementing of
an integer
– The lock statement
• Used to mark a critical section of code in a thread
lock (expression) {… }
– The Monitor class
• Provides four methods that can be used to provide
more sophisticated synchronization

C#’s Concurrency Evaluation
• An advance over Java threads, e.g., any

method can run its own thread
• Thread termination is cleaner than in Java
• Synchronization is more sophisticated

Statement-Level Concurrency
• Objective: Provide a mechanism that the
programmer can use to inform compiler of
ways it can map the program onto
multiprocessor architecture
• Minimize communication among
processors and the memories of the other
processors

High-Performance Fortran
• A collection of extensions that allow the

programmer to provide information to the
compiler to help it optimize code for
multiprocessor computers
• Specify the number of processors, the
distribution of data over the memories of
those processors, and the alignment of
data

Primary HPF Specifications
• Number of processors
!HPF$ PROCESSORS procs (n)
• Distribution of data
!HPF$ DISTRIBUTE (kind) ONTO procs ::
identifier_list
– kind can be BLOCK (distribute data to processors
in blocks) or CYCLIC (distribute data to
processors one element at a time)
• Relate the distribution of one array with that
of another
ALIGN array1_element WITH array2_element

Statement-Level Concurrency Example
REAL list_1(1000), list_2(1000)

INTEGER list_3(500), list_4(501)
!HPF$ PROCESSORS proc (10)
!HPF$ DISTRIBUTE (BLOCK) ONTO procs ::
list_1, list_2
!HPF$ ALIGN list_1(index) WITH
list_4 (index+1)
…
list_1 (index) = list_2(index)
list_3(index) = list_4(index+1)

Statement-Level Concurrency
(continued)
• FORALL statement is used to specify a list

of statements that may be executed
concurrently
FORALL (index = 1:1000)
list_1(index) = list_2(index)
• Specifies that all 1,000 RHSs of the
assignments can be evaluated before any
assignment takes place

Summary
• Concurrent execution can be at the instruction,

statement, or subprogram level
• Physical concurrency: when multiple processors are
used to execute concurrent units
• Logical concurrency: concurrent united are
executed on a single processor
• Two primary facilities to support subprogram
concurrency: competition synchronization and
cooperation synchronization
• Mechanisms: semaphores, monitors, rendezvous,
threads
• High-Performance Fortran provides statements for
specifying how data is to be distributed over the
memory units connected to multiple processors
EXCEPTION HANDLING AND
EVENT HANDLING

Topics
• Introduction to Exception Handling

• Exception Handling in Ada
• Exception Handling in C++
• Exception Handling in Java
• Introduction to Event Handling
• Event Handling with Java

Introduction to Exception Handling
• In a language without exception handling

– When an exception occurs, control goes to the
operating system, where a message is displayed
and the program is terminated
• In a language with exception handling
– Programs are allowed to trap some exceptions,
thereby providing the possibility of fixing the
problem and continuing

Basic Concepts
• Many languages allow programs to trap

input/output errors (including EOF)
• An exception is any unusual event, either
erroneous or not, detectable by either hardware or
software, that may require special processing
• The special processing that may be required after
detection of an exception is called exception
handling
• The exception handling code unit is called an
exception handler

Exception Handling Alternatives
• An exception is raised when its associated event
occurs
• A language that does not have exception handling
capabilities can still define, detect, raise, and
handle exceptions (user defined, software detected)
• Alternatives:
– Send an auxiliary parameter or use the return value to
indicate the return status of a subprogram
– Pass a label parameter to all subprograms (error return is
to the passed label)
– Pass an exception handling subprogram to all
subprograms

Advantages of Built-in Exception
Handling
• Error detection code is tedious to write and

it clutters the program
• Exception handling encourages
programmers to consider many different
possible errors
• Exception propagation allows a high level
of reuse of exception handling code

Design Issues (continued)
• How and where are exception handlers

specified and what is their scope?
• How is an exception occurrence bound to
an exception handler?
• Can information about the exception be
passed to the handler?
• Where does execution continue, if at all,
after an exception handler completes its
execution? (continuation vs. resumption)
• Is some form of finalization provided?

Design Issues
• How are user-defined exceptions specified?

• Should there be default exception handlers
for programs that do not provide their own?
• Can built-in exceptions be explicitly raised?
• Are hardware-detectable errors treated as
exceptions that can be handled?
• Are there any built-in exceptions?
• How can exceptions be disabled, if at all?

Exception Handling Control Flow

Exception Handling in Ada
• The frame of an exception handler in Ada is

either a subprogram body, a package body,
a task, or a block
• Because exception handlers are usually
local to the code in which the exception can
be raised, they do not have parameters

Ada Exception Handlers
• Handler form:
when exception_choice{|exception_choice} =>
statement_sequence
...
[when others =>
statement_sequence]
exception_choice form:
exception_name | others
• Handlers are placed at the end of the block or unit

in which they occur

Binding Exceptions to Handlers
• If the block or unit in which an exception is

raised does not have a handler for that
exception, the exception is propagated
elsewhere to be handled
– Procedures - propagate it to the caller
– Blocks - propagate it to the scope in which it
appears
– Package body - propagate it to the declaration
part of the unit that declared the package (if it is
a library unit, the program is terminated)
– Task - no propagation; if it has a handler,
execute it; in either case, mark it "completed"

Continuation
• The block or unit that raises an exception

but does not handle it is always terminated
(also any block or unit to which it is
propagated that does not handle it)

Other Design Choices
• User-defined Exceptions form:

exception_name_list : exception;
• Raising Exceptions form:
raise [exception_name]
– (the exception name is not required if it is in a
handler--in this case, it propagates the same
exception)
• Exception conditions can be disabled with:
pragma SUPPRESS(exception_list)

Predefined Exceptions
• CONSTRAINT_ERROR - index constraints, range

constraints, etc.
• NUMERIC_ERROR - numeric operation cannot return
a correct value (overflow, division by zero, etc.)
• PROGRAM_ERROR - call to a subprogram whose
body has not been elaborated
• STORAGE_ERROR - system runs out of heap
• TASKING_ERROR - an error associated with tasks

Evaluation
• The Ada design for exception handling

embodies the state-of-the-art in language
design in 1980
• Ada was the only widely used language with
exception handling until it was added to
C++

Exception Handling in C++
• Added to C++ in 1990

• Design is based on that of CLU, Ada, and
ML

C++ Exception Handlers
• Exception Handlers Form:

try {
-- code that is expected to raise an exception
}
catch (formal parameter) {
-- handler code
}
...
catch (formal parameter) {
-- handler code
}

The catch Function
• catch is the name of all handlers--it is an

overloaded name, so the formal parameter
of each must be unique
• The formal parameter need not have a
variable
– It can be simply a type name to distinguish the
handler it is in from others
• The formal parameter can be used to
transfer information to the handler
• The formal parameter can be an ellipsis, in
which case it handles all exceptions not yet
handled
Throwing Exceptions
• Exceptions are all raised explicitly by the

statement:
throw [expression];
• The brackets are metasymbols
• A throw without an operand can only
appear in a handler; when it appears, it
simply re-raises the exception, which is
then handled elsewhere
• The type of the expression disambiguates
the intended handler
Unhandled Exceptions
• An unhandled exception is propagated to

the caller of the function in which it is
raised
• This propagation continues to the main
function
• If no handler is found, the default handler
is called

Continuation
• After a handler completes its execution,

control flows to the first statement after
the last handler in the sequence of
handlers of which it is an element
• Other design choices
– All exceptions are user-defined
– Exceptions are neither specified nor declared
– The default handler, unexpected, simply
terminates the program; unexpected can be
redefined by the user
– Functions can list the exceptions they may raise
– Without a specification, a function can raise any
exception (the throw clause)
Evaluation
• It is odd that exceptions are not named and

that hardware- and system software-
detectable exceptions cannot be handled
• Binding exceptions to handlers through the
type of the parameter certainly does not
promote readability

Exception Handling in Java
• Based on that of C++, but more in line with

OOP philosophy
• All exceptions are objects of classes that
are descendants of the Throwable class

Classes of Exceptions
• The Java library includes two subclasses of

Throwable :
– Error
• Thrown by the Java interpreter for events such as heap
overflow
• Never handled by user programs
– Exception
• User-defined exceptions are usually subclasses of this
• Has two predefined subclasses, IOException and
RuntimeException (e.g.,
ArrayIndexOutOfBoundsException and
NullPointerException

Java Exception Handlers
• Like those of C++, except every catch
requires a named parameter and all
parameters must be descendants of
Throwable
• Syntax of try clause is exactly that of C++
• Exceptions are thrown with throw, as in
C++, but often the throw includes the new
operator to create the object, as in:
throw new MyException();

Binding Exceptions to Handlers
• Binding an exception to a handler is

simpler in Java than it is in C++
– An exception is bound to the first handler with a
parameter is the same class as the thrown
object or an ancestor of it
• An exception can be handled and rethrown
by including a throw in the handler (a
handler could also throw a different
exception)

Continuation
• If no handler is found in the try construct, the

search is continued in the nearest enclosing try
construct, etc.
• If no handler is found in the method, the exception
is propagated to the method’s caller
• If no handler is found (all the way to main), the
program is terminated
• To insure that all exceptions are caught, a handler
can be included in any try construct that catches
all exceptions
– Simply use an Exception class parameter
– Of course, it must be the last in the try construct

Checked and Unchecked Exceptions
• The Java throws clause is quite different
from the throw clause of C++
• Exceptions of class Error and
RunTimeException and all of their
descendants are called unchecked
exceptions; all other exceptions are called
checked exceptions
• Checked exceptions that may be thrown by
a method must be either:
– Listed in the throws clause, or
– Handled in the method

Other Design Choices
• A method cannot declare more exceptions in its

throws clause than the method it overrides
• A method that calls a method that lists a particular
checked exception in its throws clause has three
alternatives for dealing with that exception:
– Catch and handle the exception
– Catch the exception and throw an exception that is listed
in its own throws clause
– Declare it in its throws clause and do not handle it

The finally Clause
• Can appear at the end of a try construct

• Form:
finally {
...
}
• Purpose: To specify code that is to be
executed, regardless of what happens in
the try construct

Example
• A try construct with a finally clause can be used

outside exception handling
try {
for (index = 0; index < 100; index++) {
…
if (…) {
return;
} //** end of if
} //** end of try clause
finally {
…
} //** end of try construct

Assertions
• Statements in the program declaring a boolean

expression regarding the current state of the
computation
• When evaluated to true nothing happens
• When evaluated to false an AssertionError
exception is thrown
• Can be disabled during runtime without program
modification or recompilation
• Two forms
– assert condition;
– assert condition: expression;

Evaluation
• The types of exceptions makes more sense

than in the case of C++
• The throws clause is better than that of
C++ (The throw clause in C++ says little to
the programmer)
• The finally clause is often useful
• The Java interpreter throws a variety of
exceptions that can be handled by user
programs

Introduction to Event Handling
• An event is created by an external action

such as a user interaction through a GUI
• The event handler is a segment of code that
is called in response to an event

Java Swing GUI Components
• Text box is an object of class JTextField

• Radio button is an object of class JRadioButton
• Applet’s display is a frame, a multilayered
structure
• Content pane is one layer, where applets put
output
• GUI components can be placed in a frame
• Layout manager objects are used to control the
placement of components

The Java Event Model
• User interactions with GUI components
create events that can be caught by event
handlers, called event listeners
• An event generator tells a listener of an
event by sending a message
• An interface is used to make event-
handling methods conform to a standard
protocol
• A class that implements a listener must
implement an interface for the listener

The Java Event Model (continued)
• One class of events is ItemEvent, which is

associated with the event of clicking a
checkbox, a radio button, or a list item
• The ItemListener interface prescribes a
method, itemStateChanged, which is a
handler for ItemEvent events
• The listener is created with addItemListener

Summary
• Ada provides extensive exception-handling facilities

with a comprehensive set of built-in exceptions.
• C++ includes no predefined exceptions Exceptions
are bound to handlers by connecting the type of
expression in the throw statement to that of the
formal parameter of the catch function
• Java exceptions are similar to C++ exceptions
except that a Java exception must be a descendant of
the Throwable class. Additionally Java includes a
finally clause
• An event is a notification that something has
occurred that requires handling by an event handler

PPL Unit-4

Uploaded by

Copyright:

Available Formats

PPL Unit-4

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

PPL Unit-4

Uploaded by

Copyright:

Available Formats

OBJECT-ORIENTED

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-1

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-2

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-3

• Abstract data types

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-4

• Productivity increases can come from reuse

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-5

• ADTs are usually called classes

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-6

• Calls to methods are called messages

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-7

• Inheritance can be complicated by access

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-8

• There are two kinds of variables in a class:

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-9

• A polymorphic variable can be defined in a

• An abstract method is one that does not

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-11

• The Exclusivity of Objects

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-12

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-13

• Does an “is-a” relationship hold between a

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-14

• Polymorphism may require dynamic type

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-15

• Multiple inheritance allows a new class to

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-16

• From where are objects allocated?

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-17

• Should all binding of messages to methods

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-18

• If a new class is needed by only one class,

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-19

• Are objects initialized to values when they

• How are parent class members initialized

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-20

• Two interesting and challenging parts

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-21

• Class instance records (CIRs) store the state

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-22

• Methods in a class that are statically bound

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-23

• OO programming involves three fundamental concepts:

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-24

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-25

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-26

• Concurrency can occur at four levels:

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-27

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-28

• A thread of control in a program is the

• Involves a different way of designing

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-30

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-31

• Heavyweight tasks execute in their own

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-32

• A mechanism that controls the order in

GVP COLLEGE OF ENGINEERING FOR WOMEN 1-33