COEN 171 - Data Abstraction and OOP

processroguishSoftware and s/w Development

Nov 18, 2013 (3 years and 9 months ago)

110 views

(11.
1
)

COEN 171
-

Data Abstraction and OOP


Data Abstraction


Problems with subprogram abstraction


Encapsulation


Data abstraction


Language issues for ADTs


Examples

»
Ada

»
C++

»
Java


Parameterized ADTs

(11.
2
)

COEN 171
-

Data Abstraction and OOP


Object
-
oriented programming


Components of object
-
oriented programming languages


Fundamental properties of the object
-
oriented model


Relation to data abstraction


Design issues for OOPL


Examples

»
Smalltalk 80

»
C++

»
Ada 95

»
Java


Comparisons

»
C++ and Smalltalk

»
C++ and Ada 95

»
C++ and Java


Implementation issues

(11.
3
)

Subprogram Problems


No way to selectively provide visibility for subprograms


No convenient ways to collect subprograms together to
perform a set of services


Program that uses subprogram (
client program
) must
know details of all data structures used by subprogram


client can “work around” services provided by subprogram


hard to make client independent of implementation
techniques for data structures

»
discourages reuse


Difficult to build on and modify the services provided by
subprogram


Many languages don’t provide for separately compiled
subprograms

(11.
4
)

Encapsulation


One solution


a grouping of subprograms that are logically related that
can be separately compiled


called encapsulations


Examples of encapsulation mechanisms


nested subprograms in some ALGOL
-
like languages

»
Pascal


FORTRAN 77 and C

»
files containing one or more subprograms can be
independently compiled


FORTRAN 90, Modula
-
2, Modula
-
3, C++, Ada (and other
contemporary languages)

»
separately compilable modules

(11.
5
)

Data Abstraction


A better solution than just encapsulation


Can write programs that depend on abstract properties of
a type, rather than implementation


Informally, an
Abstract Data Type
(ADT) is a [collection of]
data structures and operations on those data structures


example is floating point number

»
can define variables of that type

»
operations are predefined

»
representation is hidden and can’t manipulate except through
built
-
in operations


ADT


isolates programs from the representation


maintains integrity of data structure by preventing direct
manipulation

(11.
6
)

Data Abstraction (continued)


Formally, an ADT is a user
-
defined data type where


the representation of and operations on objects of the type
are defined in a single syntactic unit; also, other units can
create objects of the type.


the representation of objects of the type is hidden from the
program units that use these objects, so the only operations
possible are those provided in the type's definition.


Advantages of first restriction are same as those for
encapsulation


program organization


modifiability (everything associated with a data structure is
together)


separate compilation

(11.
7
)

Data Abstraction (continued)


Advantage of second restriction is reliability


by hiding the data representations, user code cannot
directly access objects of the type


user code cannot depend on the representation, allowing
the representation to be changed without affecting user
code


By this definition, built
-
in types are ADTs


e.g., int type in C

»
the representation is hidden

»
operations are all built
-
in

»
user programs can define objects of int type


User
-
defined abstract data types must have the same
characteristics as built
-
in abstract data types

(11.
8
)

Data Abstraction (continued)


ADTs provide mechanisms to limit visibility


public part
indicates what can be seen (and used from)
outside

»
what is
exported


private part
describes what will be hidden from clients

»
made available to allow compiler to determine needed
information

»
C++ allows specified program units access to the private
information


friend
functions and classes

(11.
9
)

Language Issues for ADTs


Language requirements for data abstraction


a syntactic unit in which to encapsulate the type definition.


a method of making type names and subprogram headers
visible to clients, while hiding actual definitions

»
public/private


some primitive operations must be built into the language
processor (usually just assignment and comparisons for
equality and inequality)

»
some operations are commonly needed, but must be defined
by the type designer

»
e.g., iterators, constructors, destructors


Can put ADTs in PL


as a type definition extended to include operations (C++)

»
use directly to declare variables


as a collection of objects and operations (Ada)

»
may need to be instantiated before declaring variables

(11.
10
)

Language Issues for ADTs (continued)


Language design issues


encapsulate a single type, or something more?


what types can be abstract?


can abstract types be parameterized?


how are imported types and operations qualified?


Simula
-
67 was first language to address this issue


classes provided encapsulation, but no information hiding

(11.
11
)

Data Abstraction in Ada


Abstraction mechanism is the package


Each package has two pieces (can be in same or separate
files)


specification

»
public part

»
private part


body

»
implementation of all operations exported in public part

»
may include other procedures, functions, type and variable
declarations, which are hidden from clients


all variables are static

»
may provide
initialization
section


executed when declaration involving package is elaborated


Any type can be exported


Operations on exported types may be restricted


private

(:=, =, /=, plus operations exported)


limited private
(only operations exported)

(11.
12
)

Data Abstraction in Ada (continued)


Evaluation


exporting any type as private is good

»
cost is recompilation of clients when the representation is
changed


can’t import specific entities from other packages


good facilities for separate compilation

(11.
13
)

Data Abstraction in C++


Based on C struct type and Simula 67 classes


Class is the encapsulation device


all of the class instances of a class share a single copy of the
member functions


each instance of a class has its own copy of the class data
members


instances can be static, semidynamic, or explicit dynamic


Information Hiding


private

clause for hidden entities


public

clause for interface entities


protected clause
-

for inheritance

(11.
14
)

Data Abstraction in C++ (continued)


Constructors


functions to initialize the data members of instances


may also allocate storage if part of the object is heap
-
dynamic


can include parameters to provide parameterization of the
objects


implicitly called when an instance is created

»
can be explicitly called


name is the same as the class name


Destructors


functions to cleanup after an instance is destroyed; usually
just to reclaim heap storage


implicitly called when the object’s lifetime ends

»
can be explicitly called


name is the class name, preceded by a tilda (~)

(11.
15
)

Data Abstraction in C++ (continued)


Friend functions


allow access to private members to some unrelated units or
functions


Evaluation


classes are similar to Ada packages for providing abstract
data type


difference is packages are encapsulations, whereas classes
are

types

(11.
16
)

Data Abstraction in Java


Similar to C++ except


all user
-
defined types are classes


all objects are allocated from the heap and accessed
through reference variables


individual entities in classes (methods and variables) have
access control modifiers (public or private), rather than C++
clauses


functions can only be defined in classes


Java has a second scoping mechanism, package scope,
that is used instead of friends

»
all entities in all classes in a package that don’t have access
control modifiers are visible throughout the package

(11.
17
)

Parameterized ADTs


Ada
generic packages
may be parameterized with


type of element stored in data structure


operators among those elements


Must be instantiated before declaring variables


instantiation of generic behaves like text substitution


package BST_Integer is new binary_search _tree(INTEGER)

»
like text of generic package substituted here, with parameters
substituted


EXCEPT

references to non
-
local variables, etc. occur as if
happen at point where generic was declared


If have multiple instantiations, need to disambiguate when
declare exported types


package BST_Real is new binary_search_tree(REAL)


tree1: BST_Integer.bst;


tree2: BST_Real.bst;

(11.
18
)

Parameterized ADTs (continued)


C++


classes can be somewhat generic by writing parameterized
constructor functions


class itself may be parameterized as a
templated class


Java doesn’t support generic abstract data types



stack (int size) {


stk_ptr = new int [size];


max_len = size
-

1;


top =
-
1;


}


stack (100) stk;

(11.
19
)

Object
-
Oriented Programming


The problem with Abstract Data Types is that they are
static


can’t modify types or operations

»
except for generics/templates


means extra work to modify existing ADTs


Object
-
oriented programming
(OOP) languages extend
data abstraction ideas to


allow hierarchies of abstractions


make modifying existing abstractions for other uses very
easy


Leads to new approach to programming


identify real world objects of problem domain and
processing required of them


create simulations of those objects, processes, and the
communication between them
by modifying existing objects
whenever possible

(11.
20
)

Object
-
Oriented Programming (continued)


Two approaches to designing OOPL


start from scratch (Smalltalk 1972!!)

»
allows cleaner design

»
better integration of object features

»
no installed base


modify an existing PL (C++, Ada 95)

»
can build on body of existing code

»
OO features usually not as smoothly integrated

»
backward compatibility issues of warts from initial language
design

(11.
21
)

OOPL Components


Object
: encapsulated operations plus local variables that
define an object’s state


state is retained between executions


objects send and receive messages


Messages
: requests from sender to receiver to perform
work


can be parameterized


in pure OOL are also objects


return results


Methods
: descriptions of operations to be done when a
message is received


Classes
: templates for objects, with methods and state
variables


objects are instantiations of classes


classes are also objects (have instantiation method to create
new objects)

(11.
22
)

Fundamental Properties of OO Model


Abstract Data Types


encapsulation into a single syntactic unit that includes
operations and variables


also information hiding capabilities


Inheritance


fundamental defining characteristic of OOPL


classes are hierarchical

»
subclass/superclass or parent/derived

»
lower in structure inherit variables and methods of ancestor
classes

»
can redefine those, or add additional, or eliminate some


single inheritance
(tree structure) or
multiple inheritance
(acyclic graph)

»
if single inheritance can talk about a
root class

(11.
23
)

Fundamental Properties of OO Model
(continued)


Polymorphism


special kind of dynamic binding

»
message to method


same message can be sent to different objects, and the
object will respond properly


similar to function overloading except

»
overloading is static (known at compile time)

»
polymorphism is dynamic (class of object known at run time)

(11.
24
)

Comparison with Data Abstraction


Class == generic package


Object == instantiation of generic


actually, closer to instance of exported type


Messages == calls to operations exported by ADT


Methods == bodies (code) for operations exported by ADT


EXCEPT


data abstraction mechanism allows only one level of
generic/instantiation


OO model allows multiple levels of inheritance


no dynamic binding of method invocation in ADTs

(11.
25
)

OOP Language Design Issues


Exclusivity of objects


everything is an object

»
elegant and pure, but slow for primitive types


add objects to complete typing system

»
fast for primitive types, but confusing


include an imperative style typing system for primitive types,
but everything else is an object

»
relatively fast, and less confusion


Are subclasses subtypes?


does an “is a” relationship hold between parent and child
classes?

(11.
26
)

OOP Language Design Issues (continued)


Interface or implementation inheritance?


if only interface of parent class is visible to subclass,
interface

inheritance

»
may be inefficient


if interface and implementation visible to subclass,
implementation

inheritance


Type checking and polymorphism


if overridding methods must have the same parameter types
and return type, checking may be static


Otherwise need dynamic type checking, which is slow and
delays error detection


Single or multiple inheritance


multiple is extremely convenient


multiple also makes the language and implementation more
complex, and is less efficient

(11.
27
)

OOP Language Design Issues (continued)


Allocation and deallocation of objects


if all objects are allocated from heap, references to them
are uniform (as in Java)


is deallocation explicit (heap
-
dynamic objects in C++) or
implicit (Java)


Should all binding of messages to methods be dynamic?


if yes, inefficient


if none are, great loss of flexibility

(11.
28
)

Smalltalk 80


Smalltalk is the prototypical pure OOPL


All

entities in a program are objects


referenced by pointers


All
computation is done by sending messages (perhaps
parameterized by object names) to objects


message invokes a method


reply returns result to sender, or notifies that action has been
done


Also incorporates graphical programming environment


program editor


compiler


class library browser

»
with associated classes


also written in Smalltalk

»
can be modified

(11.
29
)

Smalltalk 80 (continued)


Messages


object to receive message


message

»
method to invoke

»
possibly parameters


Unary messages


specify only object and method


firstAngle sin

»
invokes sin method of firstAngle object


Binary messages


infix order


total / 100

»
sends message / 100 to object total

»
which invokes / method of total with parameter 100

(11.
30
)

Smalltalk 80 (continued)


Keyword messages


indicate parameter values by specifying keywords


keywords also identify the method


firstArray at: 1 put: 5

»
invokes at:put: method of firstArray with parameters 1 and 5


Message expressions


messages may be combined in expressions

»
unary have highest precedence, then binary, then keyword

»
associate left to right

»
order may be specified by parentheses


messages may be cascaded

»
ourPen home; up; goto: 500@500

»
equivalent to

ourPen home.

ourPen up.

ourPen goto: 500@500

(11.
31
)

Smalltalk 80 (continued)


Assignment


object <
-

object


index <
-

index + 5


Blocks


unnamed objects specified by [ <expressions> ]

»
expressions are separated by .


evaluated when they are sent the
value

message

»
always in the context of their definition


may be assigned to variables

»
foo <
-

[ ... ]


Logical loops


blocks may contain conditions


all blocks have whileTrue methods


sends value to condition block


evaluates body block if result is true

[ <logical condition> ]


whileTrue:


[ <body of loop> ]

(11.
32
)

Smalltalk 80 (continued)


Iterative loops


all integer objects have a timesRepeat method


also have

»
to:do:

»
to:by:do:


a block is the loop body


Selection


true and false are also objects


each has ifTrue:, ifFalse:, ifTrue:ifFalse:, and IfFalse:ifTrue:
methods

12 timesRepeat: [ ... ]


6 to: 10 do: [ ... ]

total = 0


“returns true or false object”


ifTrue: [ ... ]

“true object executes this; false ignores”


ifFalse: [ ... ]

“false object executes this; true ignores”

(11.
33
)

Smalltalk 80 (continued)


Dynamic binding


when a message arrives at an object, the class of which the
object is an instance is searched for a corresponding
method


if not there, search superclass, etc.


Only single inheritance


every class is an offspring of the root class Object


Evaluation


simple, consistent syntax


relatively slow

»
message passing overhead for all control constructs

»
dynamic binding of message to method


dynamic binding allows type errors to be detected only at
run
-
time

(11.
34
)

C++


Essentially all of variable declaration, types, and control
structures are those of C


C++ classes represent an addition to type structure of C


Inheritance


multiple inheritance allowed


classes may be stand
-
alone


three information hiding modes

»
public: everyone may access

»
private: no one else may access

»
protected: class and subclasses may access


when deriving a class from a base class, specify a protection
mode

»
public mode: public, protected, and private are retained in
subclass

»
private mode: everything in base class is private


may reexport public members of base class

(11.
35
)

C++ (continued)


Dynamic binding


C++ member functions are statically bound unless the
function definition is identified as
virtual


if virtual function name is called with a pointer or reference
variable with the base class type, which member function to
execute must be determined at run
-
time


pure virtual functions are set to 0 in class header

»
must

be redefined in derived classes


classes containing a pure virtual function can never be
instantiated directly

»
must be derived

(11.
36
)

Java


General characteristics


all data are objects except the primitive types


all primitive types have wrapper classes that store one data value


all objects are heap
-
dynamic, referenced through reference
variables, and most are explicitly allocated


Inheritance


single inheritance only

»
but implementing
interface

can provide some of the benefits of
multiple inheritance

»
an interface can include only method declarations and named
constants


methods can be
final
(can’t be overridden)

public class Clock extends Applet


implements Runnable

(11.
37
)

Java (continued)


Dynamic binding is the default


except for final methods


Package provides additional encapsulation mechanism


packages are a container for related classes


entries defined without access modifier (private, protected,
public) has package scope

»
visible throughout package but not outside


similarly, protected entries are visible throughout package

(11.
38
)

Ada 95


Type extension builds on derived types with
tagged types


tag associated with type identifies particular type


Classes are packages with tagged types

Package Object_Package is


type Object is tagged private;


procedure Draw (O: in out Object);


private


type Object is tagged record


X_Coord, Y_Coord: Real;


end record;

end Object_Package;


(11.
39
)

Ada 95 (continued)


Then may derive a new class by using new reserved word
and modifying tagged type exported


Overloading defines new methods

with Object_Package; use Object_package;

Package Circle_Package is


type Circle is new Object with record


radius: Real;


end record;


procedure Draw (C: in out Circle);

end Circle_Package

(11.
40
)

Ada 95 (continued)


Derived packages form tree
of classes


Can refer to type and all
types beneath it in tree by
type’class


Object’class


Square’class


Then use these as
parameters to procedures to
provide dynamic binding of
procedure invocation


Object

Circle

Square

Ellipse

Rectangle

procedure foo (OC:Object’class) is


begin


Area(OC);

--

which Area



--

determined at



--

run time


end foo;

(11.
41
)

Ada 95 (continued)


Pure abstract base types are defined using the word
abstract in type and subprogram definitions

Package World is


type Thing is abstract tagged null record;


function Area(T: in Thing) return Real is abstract;

end World;

With World;

package My_World is


type Object is new Thing with record ... end record;


procedure Area(O: in Object) return Real is ... end Area;


type Circle is new Object with record ... end record;


procedure Area(C: in Circle) return Real is ... end Area;

end My_World;

(11.
42
)

Comparing C++ and Smalltalk


Inheritance


C++ provides greater flexibility of access control


C++ provides multiple inheritance

»
good or bad?



Dynamic vs. static binding


Smalltalk full dynamic binding with great flexibility


C++ allows programmer to control binding time

»
virtual functions, which all must return same type


Control


Smalltalk does everything through message passing


C++ provides conventional control structures

(11.
43
)


Comparing C++ and Smalltalk (continued)


Classes as types


C++ classes are types

»
all instances of a class are the same type, and one can legally
access the instance variables of another


Smalltalk classes are not types, and the language is
essentially typeless


C++ provides static type checking, Smalltalk does not


Efficiency


C++ substantially more efficient with run
-
time CPU and
memory requirements


Elegance


Smalltalk is consistent, fundamentally object
-
oriented


C++ is a hybrid language in which compatibility with C was
an essential design consideration

(11.
44
)

Comparing C++ and Ada 95


Ada 95 has more consistent type mechanism


C++ has C type structure, plus classes


C++ provides cleaner multiple inheritance


C++ must make dynamic/static function invocation
decision at time root class is defined


must be virtual function


Ada 95 allows that decision to be made at time derived
class is defined


C++ allows dynamic binding only for pointers and
reference types


Ada 95 doesn’t provide constructor and destructor
functions


must be explicitly invoked

(11.
45
)

Comparing C++ and Java


Java more consistent with OO model


all classes must descend from Object


No friend mechanism in Java


packages provide cleaner alternative


Dynamic binding “normal” way of binding messages to
methods


Java allows single inheritance only


but interfaces provide some of the same capability as
multiple inheritance

(11.
46
)

Implementing OO Constructs


Store state of an object in a
class instance record


template known at compile time


access instance variables by offset


subclass instantiates CIR from parent before populating local
instance variables


CIR also provides a mechanism for accessing code for
dynamically bound methods


CIR points to table (
virtual method table
) which contains
pointers to code for each dynamically bound method