Chapter 1 - DePaul University

handprintSoftware and s/w Development

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

112 views

1

Chapter 1

Object
-
Oriented Programming

2

OO programming and design


Object
-
oriented programming and design
can be contrasted with alternative
programming approaches and associated
design techniques.


For example, object
-
oriented programming
and design can be contrasted with
procedural
programming and
top
-
down
functional decomposition
design.

3

OO programming and design


The contrast between object
-
oriented
programming and alternatives such as
procedural programming can be highlighted
by focusing on program modules.


A
module

is a program component that can
be designed, coded, translated, and tested
independently and then incorporated into a
larger program.

4

Modules


Modules in
procedural
languages such as C
are procedures, e.g., the C function


int find_max( int n1, int n2 ) {


if ( n1 > n2 ) return n1;


else return n2;


}



5

Modules


Modules in
object
-
oriented

languages such
as Java are classes, which
encapsulate
or
contain storage variables and procedures.


For example, Java has a
String

class that
encapsulates storage for the characters in a
string together with procedures for constructing
a string, determining a string’s length, checking
whether a string contains a given character, and
so on.


6

Top
-
down design


Procedural programming is associated with
a design technique known as
top
-
down
design

or
top
-
down functional
decomposition.


In top
-
down design, a problem is
decomposed into subproblems. The problem
and its subproblems are then assigned to
procedures for solution.


7

Top
-
down design



For example, the problem of building a car
might be decomposed into the subproblems of
first building the chassis, the engine, the
drivetrain, and so on and then of assembling the
prebuilt parts. The overall problem of building
the car could be assigned, in a simulation, to a
main

procedure, which in turn would invoke
subprocedures such as
build_chassis

to
handle the subproblems.

8

Top
-
down design


Top
-
down design and the associated
procedural programming have drawbacks,
particularly with respect to software
maintenance. For example, a change in
problem decomposition entails a change in
procedural decomposition, which can ripple
through an entire decomposition hierarchy.
This is known as cascading changes.

9

Top
-
down design


For instance, suppose that the
main

procedure
(which handles the main problem of building a
car) needs to be changed by, for example,
passing a new argument to subprocedures such
as
build_chassis
, which in turn need to
pass the new argument to their subprocedures,
and so on until the change in
main

has rippled
throughout the decomposition hierarchy.

10

OO design and programming


Object
-
oriented design and programming
attempt to overcome shortcomings such as
cascading changes.


In an object
-
oriented approach, classes
behave as modules that can interact with
other modules in such a way that a change
to one does not require a change to all of the
others.

11

Two senses of
class


Class

has two distinct but related senses:


In object
-
oriented design, a class is a collection
of objects such as humans that share features or
properties (e.g., humans are warm
-
blooded and
risible) and behaviors or operations (e.g.,
humans gather, hunt, cook, and even tango). A
class
Human
could represent humans in an
object
-
oriented design.

12

Class as data type


In object
-
oriented programming, a class is a
data type

that can have instances. For example,
Java has a
String

class that is a standard data
type in the language. Particular strings such as
“Mary Leakey” would be represented in Java as
String

instances or
objects
. A programmer
-
defined class such as
Human

might be
introduced as a data type to represent humans.

13

Class as data type


The classes of object
-
oriented design can be
represented in an object
-
oriented language as
class data types.


Class data types encapsulate variables to
represent class features (e.g., a variable
footCount

might be initialized to 2) and
procedures to represent operations (e.g., a
procedure might show a video of two humans
doing the tango).

14

Class and encapsulation


The class as a data type can encapsulate


variables or
fields
, which represent features or
properties that class instances share


procedures


Procedures used to create or construct instances of a
class are known as
constructors
.


Procedures that represent class operations or
behaviors are know as
methods
.

15

Class members


Fields are encapsulated variables, including
arrays or other aggregates.


Constructors are encapsulated procedures
used to construct class instances.


In Java, the code segment


new String()



uses the operator
new

and the
String()
constructor to construct a string.

16

Methods


Methods are encapsulated procedures that
provide class operations.


In Java, the code segment


String s = new String( “hi” );


int len = s.length();


first constructs a string and then invokes the
encapsulated
length

method to determine the
number of characters in the string.

17

“Class” and “instance” members


The class data types in object
-
oriented
languages have two types of members:


Members associated with the class are “class
members.” For example, an
Emp

class might
have a “class member” named
count

to track
how many
Emp

instances have been
constructed.

18

“Class” and “instance” members


Members associated with class instances are
“instance members.” For example, an
Emp

class might have a
name

“instance member” to
represent each
Emp
loyee’s name.


In Java, members marked as
static

are
“class members,” whereas members not marked
as
static

are “instance members.”

19

“Class” and “instance” members


The Java code segment


class Emp {


static int count;


String name;


}


illustrates the syntax. The field
count

is a
“class member,” whereas the field
name

is an
“instance member.”

20

Class and abstract data type


The class construct in object
-
oriented
languages directly supports
abstract data
types

data types defined by high
-
level
operations rather than by low
-
level
implementation details.


Use of abstract data rather than primitive
data types eases programming tasks.

21

Stack

as an abstract data type


A
Stack
is an example of an abstract data
type. A
Stack

is a list with insertions and
deletions done at the same end, known as
the
top
. Its high
-
level operations include


push
, which inserts an item onto the
Stack
.


pop,
which removes the
Stack
’s top item.


peek
, which shows the
Stack
’s top item without
removing it.

22

Stack class


A
Stack

class type would encapsulate
methods such as
push
,
pop
, and
peek

to
represent high
-
level
Stack

operations.Other
methods such as
isEmpty

and
isFull

could be included to test whether a
Stack

is empty or full. Constructors would be
provided to construct
Stack

instances.

23

Information hiding


An abstract data type
exposes

to clients a
high
-
level
interface

that specifies the type’s
behavior.


In the
Stack

example, the interface consists of
methods such as
push

and
pop
that specify
high
-
level operations on a
Stack
.


An abstract data type
hides

from clients the
type’s low
-
level, implementation details.

24

Information hiding


In object
-
oriented languages, a class is a
type that supports
information hiding
.


Class members such as high
-
level methods can
be declared
public

to expose such methods to
clients.


Class members that provide implementation
detail can be declared
private

to hide such
details from clients.

25

Information hiding


By directly supporting information hiding, a
class in an object
-
oriented language is well
suited for delivering abstract data types.


The Java
String

class is, in effect, an
implementation of a string as an abstract data
type.

26

Client/server model and OO


Object
-
oriented programming is based on a
client/server model of computing


A class and its instances (objects) are servers
that provide services to clients.


An application that uses a class and its
instances are clients.


For instance, the Java
String

class provides
string
-
processing services to client applications.

27

Message passing



In the client/server model, invoking a class
or instance method
sends a message
that
requests a service.


For instance, the code segment


String s = “Hi, world!”;


int n = s.length();

requests the length of the string to which
s

refers.






28

Inheritance



Object
-
oriented languages support
inheritance hierarchies, which are
parent/child relationships between classes.


For instance, a
Window

class might have
DialogWindow
as a subtype. In this case, the
Window

class is the parent class and the
DialogWindow

class is the child class.

29

Inheritance



Inheritance provides a basic form of
code
reuse
in that a child class inherits parent
class members, including the methods.


Some object
-
oriented languages (e.g., C++)
allow a child class to have multiple parent
classes. In Java, by contrast, every class
except
Object

has exactly one parent.

30

Inheritance



Languages such as C++ thus support
multiple inheritance for classes, whereas
languages such as Java support only single
inheritance for classes.


Designing inheritance hierarchies is a
critical part of object
-
oriented design.

31

Polymorphism



Polymorphism is a powerful object
-
oriented
construct in which distinct methods within
an inheritance hierarchy can be invoked
with the
same syntax
.


For instance, assume an inheritance hierarchy
of window classes in each class has its own
appropriate implementation of a
show

method,
which shows the window on the screen.

32

Polymorphism


Regardless of whether
win

refers to, say, a
MenuWindow

or a
MessageWindow
, the
statement


win.show(); // show yourself


displays the window. At run time, the systems
determines the type of window to which
win

refers and invokes the
show

method
encapsulated in that type.

33

Polymorphism



A method such as
show

is a
polymorphic
method
; that is, a method invoked with the
same syntax as other polymorphic methods
in the same inheritance hierarchy.


Polymorphism is used widely in object
-
oriented programming because of its power,
flexibility, and convenience.

34

Component
-
based programming


Modern object
-
oriented programs tend to be
component
-
based.


A
component
is a prebuilt part or module
that can be integrated with other such parts
to build or extend an application.


A
container

is a special
-
purpose component
that can hold or embed other components.

35

Component
-
based programming


Programs with graphical user interfaces are
commonly component
-
based. For example,
the user interface might consist of a framed
window (container) that holds components
such as buttons, lists, checkboxes, menus,
and the like.


Component
-
based programming is not
restricted to GUIs, however.

36

Component
-
based programming


To be easily usable, a component should be
designed under object
-
oriented principles:


The component should expose to clients only
high
-
level functionality.


The component should hide from clients the
low
-
level implementation details that support
its high
-
level functionality.


37

UML


The Unified Modeling Language (UML)
facilitates the design, development,
deployment, and maintenance of software
systems.


UML has become the modeling language of
choice for object
-
oriented design.


UML is graphical, expressive, and concise.


38

UML


Basic UML vocabulary consists of


Things: Entities to be modeled, whether
concrete or abstract.


Relationships: Connections among things.


Diagrams: graphical depictions of things and
their relationships

39

UML diagram



1






*

University

Academic Department

40

UML diagram


The diagram on the previous slide expresses
that a university is a collection of arbitrarily
many academic departments, each of which
is associated with exactly one university.


UML diagrams can serve as high
-
level
design specifications for software systems
and, in this role, can guide code
development.