Chapter 2, Outline
Introduction to Object Oriented Programming, 3rd Ed
Chapter 2
Abstraction
Outline
- Roadmap
- Abstraction
- Information Hiding
- Abstraction in an Atlas
- Levels of Abstraction in OO Programs
- Packages and Name Spaces
- Clients and Servers
- Description of Services
- Interfaces
- An Implementation of an Interface
- A Method in Isolation
- Finding the Right Level of Abstraction
- Forms of Abstraction
- Is-a and Has-A Abstraction
- Has-A Abstraction
- Is-A Abstraction
- Encapsulation and Interchangeability
- The Service View
- Other Types of Abstraction -- Composition
- Patterns
- A Short History of Abstraction Mechanisms
- Assembly Languages
- Procedures and Functions
- Information Hiding -- The Problem of Stacks
- Modules
- Parnas's Principles
- Abstract Data Types
- Three Eons of History
- Objects- ADT's with Message Passing
- What does the Future Hold?
Other Material
Intro OOP, Chapter 2, Outline
Roadmap
In this chapter we will consider abstraction, which is the most
important tool used in the control of complexity.
We will examine various abstraction mechanisms
We will present a short history of the development of abstraction tools.
Intro OOP, Chapter 2, Slide 01
Abstraction
Abstraction is the purposeful suppression, or hiding, of some
details of a process or artifact, in order to bring out more
clearly other aspects, details, or structure.
Intro OOP, Chapter 2, Slide 02
Information Hiding
Information hiding is the purposeful omission of details
in the development of an abstract representation.
Information hiding is what allows abstraction to control complexity.
Intro OOP, Chapter 2, Slide 03
Abstraction in an Atlas
Think of an atlas, and the various different levels of maps
- A map of the world, contains mountain ranges, large political boundaries
- A map of a contenent, contains all political boundaries, large cities
- A map of a country, contains more cities, major roads
- A map of a large city, roads, major structures
- A map of a portion of a city, buildings, occupants
Each level contains information appropriate to the level of abstraction.
Intro OOP, Chapter 2, Slide 04
Levels of Abstraction in OO Programs
At the highest level of abstraction we view a program as
a community of interacting objects.
Important characteristics here are the lines of communication between
the various agents.
Intro OOP, Chapter 2, Slide 05
Abstraction in OO Programs -- Packages and Name spaces
The next level of abstraction is found in some (but not all) OO languages.
A package, Unit or Name Space allows a programmer to surround a collection
of objects (a small community in itself) with a layer, and control visibility
from outside the module.
Intro OOP, Chapter 2, Slide 06
Abstraction in OO Languages -- Clients and Servers
The next level of abstraction considers the relationship between
two invidual objects. Typically one is providing a service, and the
other is using the service.
Intro OOP, Chapter 2, Slide 07
Abstraction in OO languages -- Description of Services
We can next examine just the person providing a service, independent of
the client. We define the nature of the services that are offered, but
not how those services are realized.
Intro OOP, Chapter 2, Slide 08
Levels of Abstraction in OO -- Interfaces
Interfaces are one way to describe servies at this level of abstraction.
interface Stack {
public void push (Object val);
public Object top () throws EmptyStackException;
public void pop () throws EmptyStackException;
}
Intro OOP, Chapter 2, Slide 09
Levels of Abstraction -- An Implementation
Next we look at the services provided, but from the implementation side:
public class LinkedList implements Stack ... {
public void pop () throws EmptyStackException { ... }
...
}
Concern here is with the high level approach to providing the
designated service.
Intro OOP, Chapter 2, Slide 10
Levels of Abstraction -- A Method in Isolation
Finally, we consider the implementation of each method in isolation.
public class LinkedList implements Stack ... {
...
public void pop () throws EmptyStackException {
if (isEmpty())
throw new EmptyStackException();
removeFirst(); // delete first element of list
}
...
}
Every level is important, and often you move quickly back and forth
between levels.
Intro OOP, Chapter 2, Slide 11
Finding the Right Level of Abstraction
A critical problem in early stages of development is to determine
what details are appropriate at each level of abstraction,
and (often more importantly) what details should be omitted.
One does not want to ignore or throw away important information
But one does not want to manage too much information, or have the
amount of information hide critical details.
Intro OOP, Chapter 2, Slide 12
Forms of Abstraction
Intro OOP, Chapter 2, Slide 13
Is-a and Has-A abstraction
Two of the most important types of abstraction are the following:
- Division into parts -- Has-a abstraction
- Division into specialization -- Is-a abstraction
Intro OOP, Chapter 2, Slide 14
Has-A Abstraction
Division into parts takes a complex system, and divides into into component
parts, which can then be considered in isolation.
Characterized by sentences that have the words ``has-a''
- A car has-a engine, and has-a transmission
- A bicycle has-a wheel
- A window has-a menu bar
Allows us to drop down a level of complexity when we consider the
component in isolation.
Intro OOP, Chapter 2, Slide 15
Is-a Abstraction
Is-a abstraction takes a complex system, and views it as an instance of
a more general abstraction.
Characterized by sentences that have the words ``is=a''
- A car is a wheeled vehicle, which is-a means of transportation
- A bicycle is-a wheeled vehicle
- A pack horse is-a means of transportation
Allows us to categorize artifacts and information and make it applicable to many
different situations.
Intro OOP, Chapter 2, Slide 16
Encapsulation and Interchangeability
An important aspect of division into parts is to clearly characterize the
connection, or interface, between to components.
Allows for considering multiple different implementations of the
same interface.
For example, a
car can have several different types of engine and one transmission.
Intro OOP, Chapter 2, Slide 17
The Service View
Another way to think of an interface is as a way of describing the
service that an object provides.
The interface is a contract for the service--if the interface is upheld, then
the service will be provided as described.
Intro OOP, Chapter 2, Slide 18
Other Types of Abstraction -- Composition
While is-a and has-a are two important types of abstraction, there are others.
Composition is one example; a form of has-a; characterized by the following
- Primitive forms
- Rules for combining old values to create new values
- The idea that new values can also be subject to further combination
Examples include regular expressions, type systems, windows, lots of other
complex systems.
Intro OOP, Chapter 2, Slide 19
Patterns
Patterns are another attempt to document and reuse abstractions.
Patterns are description of proven and useful relationships between
objects; which can help guide the solution of new problems.
Example pattern, Proxy:
Will have many more patterns in a later chapter.
Intro OOP, Chapter 2, Slide 20
A Short History of Abstraction Mechanisms
Another way to better understand OOP is to put it in context with the
history of abstraction in computer science.
- Assembly languages
- Procedures
- Modules
- ADT
- The Service View
- Objects
- The future....
Intro OOP, Chapter 2, Slide 21
Assembly Languages
Assembly languages and linkers were perhaps the first tools used to
abstract features of the bare machine.
- Addresses could be represented symbolically, not as a number.
- Symbolic names for operations.
- Linking of names and locations performed automatically
Intro OOP, Chapter 2, Slide 22
Procedures and Functions
Libraries of procedures and functions (such as mathematical or input/output
libraries) provided the first hints of information hiding.
They permit the programmer to think about operations in high level terms,
concentrating on what is being done, not how it is
being performed.
But they are not an entirely effective mechanism of information hiding.
Intro OOP, Chapter 2, Slide 23
Information Hiding -- The Problem of Stacks
int datastack[100];
int datatop = 0;
void init() // initialize the stack
{ datatop = 0; }
void push(int val) // push a value on to the stack
{ if (datatop < 100)
datastack [datatop++] = val; }
int top() // get the top of the stack
{ if (datatop > 0)
return datastack [datatop - 1];
return 0; }
int pop() // pop element from the stack
{ if (datatop > 0)
return datastack [--datatop];
return 0; }
Where can you hide the implementation?
Intro OOP, Chapter 2, Slide 24
Modules
Modules basically provide collections of procedures and data with import
and export statements
Solves the problem of encapsulation -- but what if your programming task requires
two or more stacks?
Intro OOP, Chapter 2, Slide 25
Parnas's Principles
David Parnas described two principles for the proper use of modules:
-
One must provide the intended user of a module with all the information
needed to use the module correctly, and with nothing more.
- One must provide the implementor of a module with all the information
needed to complete the module, and nothing more.
Intro OOP, Chapter 2, Slide 26
Abstract Data Types
An Abstract Data Type is a programmer-defined data type that can be
manipulated in a manner similar to system-provided data types
- Must have the ability to instantiate many different copies of the data type.
- Data type can be manipulated using provided operations,
without knowledge of internal representation.
But ADTs were important not because they were data structures, but because
they provided an easily characterized service to the rest of an application.
Intro OOP, Chapter 2, Slide 27
Three Eons of History
Looking at this history, we can separate it into three periods of time
functionality of an application
data types used in an application
services provided by objects in the application
Intro OOP, Chapter 2, Slide 28
Objects - ADT's with Message Passing
Characterists of Objects
-
Encapsulation -- similar to modules
-
Instantiation -- similar to ADT's
-
Messages -- dynamic binding of procedure names to behavior
-
Classes -- a way of organization that permits sharing and reuse
-
Polymorphism -- A new form of software reuse using dynamic binding
Intro OOP, Chapter 2, Slide 29
What Does the Future Hold
What will be the next evolutionary step in software?
Prediction is hard, particularly about the future.
However, one you have accepted the idea of an application formed from
interacting agents, there is no reason why those components must exist
on the same computer (distributed computing) or be written in the
same language (components).
So some of the trends we see today in software are natural results
of the OOP mind set.
Intro OOP, Chapter 2, Slide 30