Post on 05-Feb-2016
description
COSC 1030 Section 5COSC 1030 Section 5
Modularity & Data Abstraction
ObjectiveObjective
Program Language EvolutionModularityAbstract Data TypePriority Queue
Programming LanguagesProgramming Languages
FORTRAN, Algol 60– Function abstraction
Subroutine, Function and Procedure
– Primitive data types Pascal, C
– Data abstraction Record type, Structure, Union
Modula, Ada– Modularity
Compilation Unit, Incremental Compilation Interface, implementation
Programming Languages(2)Programming Languages(2)
Simula 67, Eiffel, C++, – Object Orientation– Abstract Data Types– Component Reuse
Java– Network & Security Awareness– Common Platform– Package level component
ModularityModularity
Programming ComponentCompilation UnitInterface Between ModulesInformation HidingSeparate roles – Implementer & User
ComponentsComponents
Component– File Compilation Unit– Class– Package
Compilation Unit– File Class– Dependent– Hierarchy – Small in Size
Interface between ModulesInterface between Modules
Clear and Simple– Association and Aggregation – “has”
relationship– Class Inheritance – “is a” relationship– Meaningful Naming Convention
Hierarchical– Hollywood Rule – “I call you”– Big Component Knows Small One– Specific Class Knows Generic One
Information HidingInformation Hiding Prevent Misuse Minimum Explosion
– Keep all instance variables private– Provide Public Getters– Provide Public or Protected Setters Only if Necessary
Eliminate Friends Relationship– Your friend is not my friend even if you are my friend– Break Possible Looping
Use Named Constants (final)– Hide Representation– Meaningful Name– Eliminate Duplicated Objects
Abstract Data TypeAbstract Data Type
User Defined Data Type– Extend primitive data types– Modeling problems and solutions
Data Abstraction + Operations on Data– Data has no meaning without operation– Using Operations to represent a data type
Hide Implementation Detail– Hide data representation– Hide method implementation– ADT as interface– ADT implementations
Natural Number ADTNatural Number ADT
Zero() : NSucc(n: N) NPlus(n: N, m: N) NMultiple (n: N, m: N) N
0 : NSucc(n) = n+1: NPlus(n, 0) = nPlus(n, succ(m)) = succ(plus(n, m))Multiple(n, 0) = 0Multiple(n, succ(m)) = plus(n, mulipe(n, m))
Priority Queue ADTPriority Queue ADT A finite collection of comparable items for which
the following operations are defined– Construct an initially empty priority queue(PQ)– Obtain the size of the PQ– Insert a new Item X, into the PQ– Remove from PQ an item X, of the highest priority from
PQ, if PQ is not empty highest priority item means an item X in PQ such that X Y
for all Y in the PQ
Comparable Item– Compare to another item X, produces one of the
following three status: great than (1), equals to (0) or less than (-1)
Priority Queue InterfacePriority Queue Interface
public interface PriorityQueue {
// PriorityQueue() constructs empty PQ
int size(); // number of items in PQ
void insert(Comparable x); // puts x into PQ
// removes highest priority item from PQ
// and returns the highest priority item
Comparable remove();
}
Comparable InterfaceComparable Interface
Public interface Comparable {
/**
* compare to another comparable item
* it returns 1 if this item is “great than” another
* returns 0 if this is “equals to” another
* or returns –1 is this is “less than” another
*/
int compareTo(Comparable anOtherItem);
}
Using Priority Queue ADTUsing Priority Queue ADT
Sort – Put all items into a PQ– Remove from the PQ one by one
Emergency Waiting Room– Patients registered according to time arrival– Patients are seen according to seriousness
Stock Exchange– Put orders based on time– Execute orders based on best matching
ADT ImplementationADT Implementation Different Implementations
– Different Vendors– Different Versions– Different and hidden data representations
Parallel Development– Stub Implementation– Develop and test component using stubs
Framework– Common interface – Common patterns– Different plug-ins
JAVA ADT SpecificationJAVA ADT Specification
Interface– Pure ADT, no implementation– Implements interface(s)
Abstract Class– Partially implemented ADT, need plug-ins– Extends Abstract class
Class– Implemented ADT– Refine implementation– Add Additional Operations– Extends class
Java Class HeaderJava Class Header
Modifier– Public– Abstract
Class <ClassIdentifier> Extends
– One Base Class– Single Inheritance
Implements– One or More Interfaces
Priority Queue Priority Queue ImplementationsImplementations
How to represent data– Sorted Linked List
Maintain order when insert Return first node when remove
– Array Insert: increase array size if necessary; write to the
last position and increase last position Remove: find the highest priority item; move the
last item to the position where highest priority item occupied;
Sorted Linked List Impl.Sorted Linked List Impl.public class PriorityQueueImpl implements PriorityQueue { private LinkedList sortedList = null; public PriorityQueue() {
sortedList = new LinkedList(); // empty list } public void insert(Item newItem) { ListNode previousNode = findInsertPositionFor(newItem); sortedList.insertAfter(previousNode, new ListNode(newItem)); } public Item remove() {
return sortedList.remove(FIRST); } public size() { return sortedList.size(); } private ListNode findInsertPositionFor(Item anItem) {…}}
Helper Method Helper Method private ListNode findInsertPositionFor(Item anItem) { ListNode currentNode = sortedList.getFirst(); ListNode previousNode = null; while(currentNode != null) { if(anItem.compareTo(currentNode.getItem() > 0) {
break; // found the insert position } else { previousNode = currentNode; currentNode = currentNode.getNext(); } // end if } // end while return previousNode;}
Array ImplementationArray Implementation
Class PriorityQueueImpl2 implements PriorityQueue { private int count; private final int capacityIncrement; private Item[] itemArray; public PriorityQueueImple2() { count = 0; capacityIncrement = 5; itemArray = new ItemArray[10]; } public int size() { return count; } public void insert(Item newItem) { if(count == itemArray.length) { increaseCapacity(); } itemArray[count++] = newItem; }
Copy ArrayCopy Array
private void increaseCapacity() {
capacity += capacityIncrement;
Item[] tempArray = new Item[capacity];
for (int I = 0; I < itemArray.length; I++) {
tempArray[I] = itemArray[I];
}
itemArray = tempArray;
}
public Item remove() { Item maxItem = null; if(count != 0) { int maxPosition = findMaxPosition(); maxItem = itemArray[maxPosition];
itemArray[maxPosition] = itemArray[--count]; itemArray[count] = null; // clean up } // end of if; return maxItem; } // end of remove} // end of PriorityQueueImpl2
remove methodremove method
maxPosition MethodmaxPosition Method
private int maxPosition() { int maxPosition = 0;
maxItem = itemArray[0]; for(int I = 0; I < count; I ++) { if(itemArray[I].compareTo(maxItem) > 0) {
maxPosition = I; maxItem = itemArray[I];
} // end of if // assert(maxItem == maximum(itemArray[0:I]));
} // end of for return maxPosition;} // end of maxPosition
Test Priority QueuesTest Priority QueuesClass PriorityQueueTester { public static void main(String[] args) {
PriorityQueue aPQ = new PriorityQueueImpl1();
aPQ.insert(“red”);
aPQ.insert(“green”);aPQ.insert(“yellow”);
aPQ.insert(“blue”);aPQ.insert(“white”);
while(aPQ.size() > 0) { York.println(aPQ.remove());
} // end of while } // end of main} // end of PriorityQueueTester