Transcript Object Oriented Programming

Object Oriented Programming
Chapter 13
13.1: Abstract Data Types
• Imperative program design is based on
functional decomposition, which systematically
refines the problem into smaller and smaller
parts until the functions are small enough to
represent in primitive language statements.
• Procedural or functional abstraction:
programmers think about the program in terms
of function interfaces and functionality (what
does it do?)
Data Abstraction
• Extends the idea of procedural abstraction
to the data
• Abstract data type: a set of values, and the
operations that can be performed on them.
• ADT: provides encapsulation for new data
types
Encapsulation - Definition
• Encapsulation is a mechanism which
allows logically related constants, types,
variables, methods, and so on, to be
grouped into a new entity.
• Encapsulation mechanisms limit the scope
and visibility of data and functions.
Examples: procedure, packages, classes.
History
• Today, OO programming is the preferred
way to implement encapsulation.
• Objects aren’t new – Simula 67, Smalltalk76 and Smalltalk-80.
• Other methods include …
Encapsulation Mechanisms
• C: (13.2-13.3) Header file +
implementation file
• Modula 2: Modules – definition and
implementation
• Ada: (13.4-13.5) Package – definition and
implementation
Abstract Stack Designs/Fig
13.2
• Figure 13.2, 13.3: primitive version of ADT
– Encapsulates data and operations for an
integer stack
– Linked structure, composed of value/pointer
nodes
• Header + implementation files.
• Can’t generalize to other data types
A Stack Type in C
Figure 13.2
stack.h
header file to specify the
STACK data type.
Figure 13.3 – Implementation
• Implementation file shows typical stack
functions:
– empty, newstack, pop, push, top
• Any program that includes the header can
declare variables of type STACK and use
the functions in the implementation file
Independent Compilation ≠
ADT
• Now we have a stack data type and a way to
dynamically declare stack variables, but…
– There’s no way to prevent the client from bypassing
the defined stack operations to directly access a stack
variable; e.g. to search the stack for a particular value
– There’s no way to generalize to other data types
• Better: force stack access to be only through the
interface (defined stack functions).
• No inheritance, no encapsulation.
Objectives of Data Abstraction
• Prevent public access to the underlying
ADT representation and
• provide a public interface to the ADT
through its operations (functions) and
prevent any other access; i.e.,
– provide information hiding by packaging data
and functions together in a unit that provides
access only through the defined interface.
Purpose
• The purpose of information hiding is to
protect the rest of the program from
implementation changes.
• Stable interface
Information Hiding Mechanisms
• Pascal “units”, Modula “modules” and
Ada “packages” support these goals.
• Developers are able to prevent direct
access to the underlying representation
• These early versions provide
encapsulation but lack other desirable
characteristics.
Ada Packages – page 313
• Figures 13.4 & 13.5 contain the Ada
specification for a generic stack.
• Ada packages are similar to C++/Java
class definitions
• Two parts: package definition &
package implementation.
• Data and functions can be public or
private.
Ada Packages
• Package definition (13.4, p. 313):
– Data + function declarations
– Private and public (default) specification
• Package implementation (13.4, p 314)
– Function implementations
• Package stack_pck is generic; instantiate
with
package int_stack is
new stack_pck(element=>integer);
Problems with Modules,
Packages, etc.
• No mechanism for automatic initialization or
for finalizing; e.g. open/close, memory alloc.
• No simple way to extend ADT by adding new
operations, modifying data characteristics,
etc. (No inheritance)
• Some computing paradigms (e.g. GUIbased) were not well modeled by imperative
programming style
OO v Imperative Paradigm
• Imperative: Design approach is functional
decomposition + limited-feature abstract
data types.
• Object oriented: Design approach is object
decomposition. Objects include both
functions and data.
OO Programming/History
• Simula, an early (mid to late 60’s) OO
language, was developed as a simulation
language
– Included features for modeling the objects
that participated in the simulations
• Smalltalk (early 80’s) was the first
language to call itself object-oriented, but
concepts came from Simula.
Classes
• Class: a type declaration which encapsulates
constants, variables, and functions for
manipulating these variables.
• A class is itself an abstract data type and a
mechanism for defining ADTs in programs.
• OO languages support encapsulation and
information hiding
Section 13.2: The ObjectOriented Model
• Object: an instance (variable) of the class
• Instance variables: the local variables of a class.
Also called member variables, fields, …
• Methods: functions that operate on objects
• Local variables: variables declared in a method
• Message: a request to perform an operation on
an object (function call).
• Client (of a class): a program or class or method
that uses an object of the class data type
OO Languages Address the
Problems That Exist in Modules
• Inheritance
– Allows classes to be modified and specialized, which
improves reusability.
• Constructors
– Special methods that initialize local instance variables
• Destructors
– Some languages have these to finalize objects when
they are no longer needed; e.g. free memory when an
object’s scope ends.
Features of OO Languages
•
•
•
•
•
Program Organization
Visibility and Information Hiding
Methods and Constructors
Inheritance
Polymorphism
OO Program
• An object-oriented program is modeled as
a collection of objects that communicate
with each other and the user by sending
and receiving messages.
• Classic example: GUI application
– Objects = buttons, text areas, pull-down
menus, etc.
Class Definition - Java
public class C {
private int i, j:
// instance
// variables
public C (<params>)
{<code>}
// a constructor
public <type> M (<params>)
{<code>}
// a method
} //end class C
Class Definition – C++
class C {
private: int i, j:
// instance
// variables
public:
C::C (<params>)
{<code>}
// a constructor
<type> C::M (<params>)
{<code>}
// a method
} //end class C
Object Declaration and
Initialization (Java syntax)
• Declare a variable as an object from the class
C: (declaration)
C x;
No storage is allocated.
• Declare & initialize a variable x that is an
object from class C: (definition)
C x = new C(<arguments>);
• A new object is allocated on the heap and
assigned values.
Initialization of an Object in the Heap
Figure 7.6
Objects v. Data Structures
• Objects are active, as opposed to the
traditional view of data structures as
entities that are acted on by functions.
• A message is similar to a function call, but
instead of being made by one function to
another, a message may be sent from one
object to another.
Visibility in OO Languages
• Visibility characterizes the degree of information hiding
attached to components (methods, instance variables) of
a class.
• Visibility modifiers include
– Private: visible only to the current class.
– Protected: visible also to a class’s subclasses &, in
Java, to members of other classes in the same
package (an unfortunate design decision, according to
the authors)
– Public: visible to any client or subclass of the class
Visibility in OO Languages
• Friend functions in C++ can access private
members of other classes.
– Declared by the class it can access
– Used as a stand-alone function
• Usually: class data is private (information hiding)
and methods public
– forces clients to interface with the class through
its API (interface).
– If concrete implementation of data changes,
client classes and subclasses aren’t affected.
Figure 13.8 Stack Class with Visibility
Modifiers
public class MyStack{
Note the inclusion of
protected class Node {
an inner class (not the
public Object val;
same as a subclass)
public Node next;
public Node (Object v, Node n){
val = v; next = n;
The MyStack class is
}
public, the Node
}
class is protected
private Node theStack;
(visible only to
public MyStack ( ) {theStack = null;}
public boolean empty ( ) { return theStack == null;} subclasses.) Stack
data is private, the
public Object top( ) { return theStack.val; }
interface is defined
public Object pop( ) {
by the functions
Object result = theStack.val;
empty, top, etc.
theStack = theStack.next:
return result;
}
public void push(Object v) {
theStack = new Node(v, theStack);
}
}
Constructors & Other Methods
• Note constructors in myStack example.
• Constructors are invoked by the new operation;
heap space is allocated and instance variables
may be intialized
– Node objects are initialized to values,
– MyStack objects are initialized to the null pointer
• Constructors are examples of class methods.
– Not invoked through a specific object
• push, pop, etc. are examples of instance
methods and are invoked through an object.
Using the Stack
• Declare a myStack object as follows:
myStack s = new myStack();
• Create a stack with the values 1 and 5:
s.push(1);
s.push(2);
s.pop();
// creates garbage
s.push(5);
Creation of a Stack with Two Values
Figure 13.7
Inheritance: The Class
Hierarchy
• Parent or superclass, child or subclass
• is-a relation: a member of a subclass is-a
member of the superclass
• has-a relation: if class A is a client of class B,
then A has-a B (has-a doesn’t reflect a
subclass-superclass relationship)
• Has-a relation between classes sometimes is
called an aggregation: C1 is an aggregation of
C2 if C1 contains objects of type C2.
Inheritance
• If D is a subclass of C, then D can inherit
from C, or acquire attributes (instance
variables and methods, including
constructors) from it.
• In this case we may refer to C as the base
class and D as the derived class.
• In some languages, we say D extends C
• Inheritance supports code reuse
Single Inheritance
• Single inheritance limits a class to having
only one superclass.
• Single inheritance produces a class
hierarchy that can be represented as a
tree, with a single root. (Object, in Java)
Multiple Inheritance
• A class may have multiple superclasses.
• Inheritance from more that one parent has
good features and bad.
– Good: facilitates code reuse by borrowing
characteristics from several parent classes
– Bad: confusing. For example, what if two
parent classes have a method with the same
name, but different definitions?
Definition
• A language is object-oriented if it supports (1) an
encapsulation mechanism with information
hiding for defining abstract data types; e.g.,
classes (2) virtual methods, and (3) inheritance.
• A language is object-based if it allows a program
to create any number of instances of an abstract
data type.
• You may also see the 3 characteristics listed as
(1) classes, (2) polymorphism, and (3)
inheritance.
Virtual Methods &
Polymorphism
• Informally, a class method is virtual if its
subclasses (inheriting classes) can override the
implementation in the original class.
• Virtual methods allow OO languages to express
polymorphism: the late binding of a call to one
of several different implementations in an
inheritance hierarchy.
Kinds of Polymorphism
• Parametric polymorphism: a function is defined as a
template or generic.
– Apply the same operations, in the same way, to different types
• In subtype polymorphism, virtual (polymorphic) functions
can also be applied to variables of different types, but the
functions themselves behave differently.
– Also called inclusion polymorphism because it’s a result of
inheritance & sub-typing.
• Function or operator overloading is sometimes called ad
hoc polymorphism.
Templates
• A template defines a family of classes
parameterized by one or more types
• Example: collection classes such as lists,
stacks, queues, hash tables.
– A list can have members from different types:
list of integers, list of strings, etc.
• Templates are also called generics.
• Function code is written without any
reference to types.
(sub-type) Polymorphism
• Polymorphic functions have different
implementations, depending on the
subclass, but all have the same general
purpose.
• In a way, polymorphism is a form of
information hiding – makes it possible to
specify a general kind of behavior, and
worry about details later (when subclasses
are defined)
Example: Class Hierarchy
Drawable
paint()
Triangle
Square
Ellipse
Circle
The class “Drawable” has several subclasses, each of which has its own version of
the paint function. A list (myList) of drawable objects is maintained. To draw
each object:
for(Drawable obj : myList) // uses the appropriate paint method
obj.paint();
Principle of Substitutability
• A subclass method is substitutable for a
parent class method if the subclass’s
method performs the same general
function
– E.g. “draw” – but note that it is the same
function only in an abstract sense.
• This is the essence of polymorphism in
OO languages.
Abstract Classes
• Abstraction is an essential feature of
computer science. It is a way of filtering
out specific details in order to focus on a
few important concepts.
• In OO programming, abstract classes
support this design mechanism.
Abstract Class
• An abstract class is one that is either
declared to be abstract or has one or more
abstract methods.
• An abstract method is a method that
contains no code beyond its signature.
– signature = prototype
• It’s not possible to instantiate an object
from an abstract class.
An Abstract Class
• An abstract class can represent an abstract
concept.
Example:Clite Expression
• Abstract syntax rule:
Expression = VariableRef | Value | Binary |
Unary
• A Java implementation includes an abstract
class Expression with subclasses Variable,
Binary, Unary, Value.
Fig. 13 Clite Expression as an
Abstract Class
Expression
(abstract) display
Variable
display
IntValue
display
Value
FloatValue
display
Unary
display
Binary
display
BoolValue
display
CharValue
display
Java Interfaces
• Encapsulate a collection of constants and abstract
method signatures. An interface may not include
either variables, or constructors, or nonabstract
methods.
• Declared like an abstract class, except with the word
interface. ( public interface Map {…} )
• All methods in an interface are abstract & must be
implemented by any class that implements the
interface.
Java Interfaces
• A class may implement multiple interfaces, which
allows it to appear to be many different types.
• Similar to multiple inheritance
• A class can inherit from its parent, but also draw
features from interfaces.
– No danger of conflicting method definitions if the parent
and interface have same-named methods; the class is
required to re-implement the method
Summary
• OO languages
– support encapsulation and data abstraction
through the class mechanism
– Provides constructors
• Characterized by inheritance and sub-type
polymorphism
• Support run-time type identification (RTTI)
which allows an object’s type to be
identified at run time