Abstract data types & object-oriented paradigm
Abstraction• Abstraction: a view of an entity that includes o
nly the attributes of significance in a particular context.
• Two fundamental abstractions: process abstraction & data abstraction
• Process abstraction: sortInt(list, list_len)– sorting algorithms is not revealed– user code remains same even implementation of s
orting algorithm is changed– used for a long time
Abstract data type• Abstract Data Type: an encapsulation that
includes only the data representation and the subprograms that provides operations for that type.– reliability: user cannot directly access objects– readability: without implementation details
Introduction to Data Abstraction
• Built-in types are abstract data types
e.g. int type in Java– 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– To declare variables of that type– A set of ops
Abstract data type example
interfaces:create(stack)destroy(stack)empty(stack)push(stack, ite
m)pop(stack)top(stack)
code example: …create(stk1);push(stk1, 34);push(stk1, 20);if ( !empty(stk1) )
temp = top(stk1);
• stack implementation can be changed from array to list w/o affecting the code
Encapsulation
• Encapsulation: a grouping of subprograms and the data they manipulate
• Hiding the implementation details of the abstract interface
• Protect internal data
• Reliability, maintenance
Language Examples-C++• Based on C struct type and Simula 67 clas
ses• The class is the encapsulation device• All of the class instances of a class share a si
ngle copy of the member functions• Each instance of a class has its own copy of t
he class data members• Instances can be static, stack dynamic, or he
ap dynamic
At first glance#include <iostream.h>class stack {
private: int *stackPtr; int maxLen; int topPtr;public: stack() {
stackPtr = new int [100];
maxLen = 99;topPtr = -1;
} ~stack() {
delete [ ] stackPtr; }
void push(int item) {if (topPtr == maxLen) cerr << “Stack full\n”;else stackPtr[++topPtr] = it
em; } void pop() {
if (topPtr == -1) cerr << “Stack empty\n”;else topPtr--;
} int top() {
return ( stackPtr[topPtr] ); } int empty() {
return ( topPtr == -1); }} // end class stack
Data members
Member functions
C++ Class• data members: data defined in a class
– *stack_ptr, max_len, top_ptr
• member functions: functions defined in a class– also called access interfaces– push( ), pop( ), top( ), empty( )
• private: entities (data or member functions) that are to be hidden from outside the class
• public: entities (data or member functions) that are visible outside the class
C++ class (con’t)• constructor: initialize the data members
of newly created objects– stack( )– implicitly called when an object of the class
type is created– can have one or more constructor for a
class
• destructor: implicitly called when the lifetime of an instance of the class ends– ~stack( )
Example in C++#include <iostream.h>class stack {
private: int *stackPtr; int maxLen; int topPtr;public: stack() {
stackPtr = new int [100];
maxLen = 99;topPtr = -1;
} ~stack() {
delete [ ] stackPtr; }
void push(int item) {if (topPtr == maxLen) cerr << “Stack full\n”;else stackPtr[++topPtr] = it
em; } void pop() {
if (topPtr == -1) cerr << “Stack empty\n”;else topPtr--;
} int top() {
return ( stackPtr[topPtr] ); } int empty() {
return ( topPtr == -1); }} // end class stack
Class usage in C++Code example in C++:
void main() {
int topOne;
stack stk;
// stack-dynamic
stk.push(42);
stk.push(20);
topOne = stk.top();
stk.pop();
…
// stk being freed
}
• stack stk constructor is called to initialize the instance
• at the end of the main, stk’s destructor is called
Language Examples
• 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
Language Examples
• 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
tilde (~)
Examples in Java
Code example in C++:
void main() {
int topOne;
stack stk; // stack-dynamic
stk.push(42);
stk.push(20);
topOne = stk.top();
stk.pop();
…
}
Code example in Java:
public class TestStack {
public static void main(…) {
INTEGER topOne;
StackClass myStack =
new StackClass();
myStack.push(42);
myStack.push(20);
topOne = myStack.top();
myStack.pop();
…
}
• Java uses implicit garbage collection (no destructor) and reference variable (not pointer)
Java features
• Stack_class does not have destructor– implicit garbage collector
• In main( ), myStack does not get freed– implicit garbage collector
• The use of reference variables– Java does not support pointer
Example:Stack in Javaimport java.io.*;class Stack_class {
private int [ ] stack_ref;private int max_len,
top_index; public Stack_class( ) { stack_ref = new int [100]; max_len = 99; top_index = -1; } public void push (int number) { if (top_index = max_len) System.out.println(
“Error stack full”); else
stack_ref[++top_index] = number;
}
public void pop( ) {if (top_index == -1)
System.out.println( “Error Stack empty”);
else –top_index; } public int top( ) { return (stack_ref[top_index]); } public boolean empty( ) { return (top_index == -1); } } // end class stack
Parameterized Abstract Data Types- C++
• Templated Classes– Classes can be somewhat generic by writin
g parameterized constructor functions, e.g.
stack (int size) { stk_ptr = new int [size]; max_len = size - 1; top = -1; } stack stk(100);
Parameterized Abstract Data Types
• The stack element type can be parameterized by making the class a templated class
• Java does not support generic abstract data types
Parameterized Abstract Data in C++
#include <iostream.h>class stack {
private: int *stackPtr; int maxLen; int topPtr;public: stack(int size) {
stackPtr = new int [size];
maxLen = size -1;topPtr = -1;
} ~stack() {
delete [ ] stackPtr; }
void push(int item) {if (topPtr == maxLen) cerr << “Stack full\n”;else stackPtr[++topPtr] = item;
} void pop() {
if (topPtr == -1) cerr << “Stack empty\n”;else topPtr--;
} int top() { return ( stack[topPtr] ); } int empty() {
return ( topPtr == -1); }} // end class stack
Usage: stack myStack(50);
Template abstract data type in C++
#include <iostream.h>
template <class Type>
class stack {
private:
Type *stackPtr;
public:
stack()
: stackPtr (new Type [100]),
maxLen (99), topPtr(-1)
{ }
stack(int size) {
stackPtr = new Type [size];
maxLen = size – 1;
topPtr= -1; }
• C++ example in leftstack<int> stk;stack<int> stk(150);
• C++ template classes are instantiated at compile time– code for new type is cre
ated when not existed
• Java does not support generic abstract data type as in left
Encapsulation Constructs• Original motivation:
– Large programs have two special needs:
1. Some means of organization, other than simply division into subprograms
2. Some means of partial compilation (compilation units that are smaller than the whole program)
• Obvious solution: a grouping of subprograms that are logically related into a unit that can be separately compiled (compilation units)– These are called encapsulations
Encapsulation Constructs• Nested subprograms in Ada and Fortran 95• Encapsulation in C
– Files containing one or more subprograms can be independently compiled
– The interface is placed in a header file– Problem: the linker does not check types betwee
n a header and associated implementation
• Encapsulation in C++ – Similar to C– Addition of friend functions that have access to pr
ivate members of the friend class
Naming Encapsulations• Large programs define many global
names; need a way to divide into logical groupings
• A naming encapsulation is used to create a new scope for names
• C++ Namespaces– Can place each library in its own
namespace and qualify names used outside with the namespace
– C# also includes namespaces
OO Key feature• Abstraction
– Well-defined interface
• Hierarchy – Composition– Derivation– inheritance
• Encapsulation– Hiding the detail
• Polymorphism
From C to C++
• Without abstraction main(){
int stack_items[STACKSIZE], stack_top =0, x;
/*push x into stack*/
stack_item[stack_top++] = x;
/*pop stack to x*/
x = stack_item[--stack_top];
}
Abstraction• Abstraction:void init(stack *s;viod push(stack *s, int i);int pop(stack *s);void cleanup(stack *s);
typedef struct{int items[stacksize];
Int top} stack;Void init(stack *s) {s->top = 0;}Void push (stack *s, int i) {s-> items
[s->top++] =I;}Int pop(stack *s){return s->items[--
s->top];}…
main(){int x;stack stack1;init(&stack1);push(&stack1, x);…
}