Chapter 11 Abstract Data Types and Encapsulation Concepts
Chapter 11 Abstract Data Types and Encapsulation Concepts ISBN 0 -321 -49362 -1
Chapter 11 Topics • • Steve Adds: Motivation and History of Abstraction The Concept of Abstraction Introduction to Data Abstraction Design Issues for Abstract Data Types Language Examples Parameterized Abstract Data Types Encapsulation Constructs Naming Encapsulations Copyright © 2015 Pearson. All rights reserved. 1 -2
Motivation of Abstracti m CSE 4102 m m m As Software has Become more Complex, it Requires more Software Engineers F. Brooks - Mythical Man Month - 1970 s q Work done in 2 months by 1 Software Engineer > Work done in 1 month by 2 SEs! q “Adding Software Engineers to a Late Project will only Make it Later!” WHY? Interconnectedness: Interdependencies in Code q Individual Portions can’t be Written in Isolation q Information Exchange Needed Between SEs Complexity Historically Controlled by Abstracting Away Less Important Details 3
Separation of Concerns m m CSE 4102 m m Divide and Conquer Problem Solving Technique Identify the Different Aspects of Problem q Time Considerations - Scheduling q Focus on Qualities of Primary Concern q Alternate Views of Problem - Data vs. Control q Size-Oriented Decomposition Today’s Applications involve Interoperability of q New C/S, Legacy, COTS, Databases, etc. q Multiple Prog. Languages (C, C++, Java, etc. ) q Heterogeneous Hardware/OS Platforms Separation of Concerns is Critical! 4
History of Abstraction Procedures and Modules m CSE 4102 m Procedures q The “First” Abstraction Mechanism q Repeated Execution of Same Code without Duplication q Inefficient at Information Hiding Modules: Managing Name Spaces q Public: Portion Accessible Outside Module q Private: Portion Accessible Inside Module q Users can Only “See” Information Needed to Utilize Module q SE can Only “See” Information Needed to Code Module q Supports Information Hiding 5
Modularity m m CSE 4102 m m m Compose and Design Systems as Set of Modules Two-Phase Application of Separation of Concerns q Define Details of Individual Modules q Characterize Interactions Among All Modules Three Goals of Modularity q Decomposability: Problem to Subproblems q Composability: Combine to Solution q Abstraction: Capability of Understanding Levels of Modules in Programming q C: “. h/. c” Pairs - Ad-hoc Modularity q C++: “. h/. c” Pairs for Classes q Ada 95/Java: Adds the Package Concept Maximize Cohesion and Minimize Coupling 6
Abstraction m CSE 4102 m m Remove/Hide Unimportant Details to Allow more Important Aspects of a Product to be Considered Widely Utilized to Reduce Complexity Abstractions Dominate Computing q Paradigms (OO, Top-Down, Functional, etc. ) q Design Models (CRC, OMT, UML, etc. ) q Programming Languages (C, C++, Java, etc. ) People Think and Learn in Abstractions Goals of Advances in Design and Programming q Provide Robust Sets of Abstractions q Allow Modeling to Occur Close to Real World 7
The Concept of Abstraction • An abstraction is a view or representation of an entity that includes only the most significant attributes • The concept of abstraction is fundamental in programming (and computer science) • Nearly all programming languages support process abstraction with subprograms • Nearly all programming languages designed since 1980 support data abstraction Copyright © 2015 Pearson. All rights reserved. 1 -8
Introduction to Data Abstraction • An abstract data type is a user-defined data type that satisfies the following two conditions: – The representation of objects of the type is hidden from the program units that use these objects, so the only operations possible are those provided in the type's definition – The declarations of the type and the protocols of the operations on objects of the type are contained in a single syntactic unit. Other program units are allowed to create variables of the defined type. Copyright © 2015 Pearson. All rights reserved. 1 -9
Advantages of Data Abstraction • Advantages the first condition – Reliability--by hiding the data representations, user code cannot directly access objects of the type or depend on the representation, allowing the representation to be changed without affecting user code – Reduces the range of code and variables of which the programmer must be aware – Name conflicts are less likely • Advantages of the secondition – Provides a method of program organization – Aids modifiability (everything associated with a data structure is together) – Separate compilation Copyright © 2015 Pearson. All rights reserved. 1 -10
Abstract Data Types (ADTs) m m CSE 4102 m m m Proposed by B. Liskov (MIT) for CLU in 1975 ADTs Promote Application Development From Perspective of Information and its Usage ADT Design Process: q Identify “Kinds” or “Types” of Information q Encapsulate Information and Provide a Public Interface of Methods q Hide Information and Method Code in the Private Implementation ADTs Correspond to User-Defined Data Types Analogous to Integer Data Type and +, -, *, etc. 11
Abstract Data Types (ADTs) m Consider the following Example Stack ADT: Public Interface CSE 4102 Private Implementation Head: Int; ST: Array[100] of Int; User PUSH POP TOP EMPTY Designer Push(X Int) … End; Int Pop() … End; PUSH 5 10 15 20 20 15 10 5 ST 5 TOP 20 15 10 5 12
ADT Design Guidelines m CSE 4102 m m Separation of Concerns and Modularity q Problem Decomposable into Components Abstraction and Representation Independence q Hiding Implementation of Components q Changing without Impacting External View Incrementality and Anticipation of Change q Components are Changed, Added, Refined, etc. , as Needed to Support Evolving Requirements Cohesion: Well-Defined Component Performs a Single Task or has a Single Objective Coupling: Component Interactions are Known and Minimal 13
Benefits of ADT Paradigm m CSE 4102 m m Supports Reusable Software Components q Creation and Testing in Isolation q Integration of Working Components q Designers/Developers View Problem at Higher Level of Abstraction Controls Information Consistency q Public Interface Limits Access to Data q Private Implementation Unavailable Promotes/Facilitates Software Evolution/Reuse q Inheritance to Extend Design/Class Library q Multiple Instances of Same Class 14
High-Tech Supermarket System (HTSS) m CSE 4102 m m Automate the Functions and Actions q Cashiers and Inventory Updates q User Friendly Grocery Item Locator q Fast-Track Deli Orderer q Inventory Control User System Interfaces q Cash Register/UPC Scanner q GUI for Inventory Control q Shopper Interfaces Locator and Orderer q Deli Interface for Deli Workers We’ll Introduce and Utilize Throughout Course 15
The HTSS Software Architecture IL CSE 4102 IL IL SDO EDO Payment CR CR IL: CR: IC: DO: Item Locator Cash Register Invent. Control Deli Orderer for Shopper/Employee Item Order IC IC Non-Local Client Int. Credit. Card. DB Inventory Control Item. DB Global Server Item. DB Local Server ATM-Ban. KDB Order. DB Supplier. DB 16
Programming with ADTs m CSE 4102 m m ADTs Promote Applications Development From Perspective of Information and Its Usage ADT Design Process and Steps: q Identify Major “Kinds/Types” of Information q Describe Purpose Each Kind or Type q Encapsulate Information q Define and Characterize Methods Process Iterates/Cycles from Bottom Up q Focus on Lowest Level of Info. - Build ADTs q Next Level of ADTs Use Lowest Level q Next Level Combines most Recent Levels q Repeat to Achieve Desired System level 17
ADTs in HTSS CSE 4102 ADT Item; PRIVATE DATA: SET OF Item(s), Each Item Contains: UPC, Name, WCost, RCost, On. Shelf, In. Stock, Location, ROLimit; PTR TO Current_Item; PUBLIC OPS: Create_New_Item(UPC, . . . ) : RETURN Status; Get_Item_Name. Cost(UPC) : RETURNS (STRING, REAL); Modify_Inventory(UPC, Delta) ; Get_In. Stock_Amt(UPC) : RETURN INTEGER; Get_On. Shelf_Amt(UPC) : RETURN INTEGER; Check_If_On_Shelf(UPC): RETURN BOOLEAN; Time_To_Reorder(UPC): RETURN BOOLEAN; Get_Item_Profit(UPC): RETURN REAL; . . . {notes: - OPS span the entire application - not limited to a single, functional component} END Item; ADT Deli. Item; ADT Customer. Info; PRIVATE DATA: SET OF (Item, Weight, . . . Cost. Lb, Increm); END Customer. Info; . . . END Deli. Item; 18
ADTs in HTSS ADT Process_Order; {middle-level ADT} PRIVATE DATA: {local variables to process an order} PUBLIC OPS : {what do you think are appropriate? } CSE 4102 {this ADT uses the ADT/PUBLIC OPS from Item, Deli_Item, Receipt, Coupons, and Customer_Info to process and total an Order. } END Process_Order; ADT Sales_Info; {middle-level ADT} PRIVATE DATA: {local variables to collate sales information} PUBLIC OPS : {what do you think are appropriate? } {this ADT uses the ADT/PUBLIC OPS from Receipt so that the sales information for the store can be maintained. } END Sales_Info; ADT Cashier; {high-level ADT} {this ADT uses the ADT/PUBLIC OPS from the middle-level ADTs (Process_Order, Sales_Info, etc. ). ) END Cashier; 19
Advantages/Drawbacks of ADTs m CSE 4102 m m Advantages: q Abstraction is Promoted and Achieved q Concurrent Engineering is Feasible q Reuse and Evolution are Attainable q Emphasizes Static System Behavior Drawbacks: q Without Inheritance, Redundancies Likely q Dynamic System Behavior Still Difficult q Associations Between ADTs Difficult q Only Inclusion Association Supported Do Drawbacks Outweigh Advantages? 20
Language Requirements for ADTs • A syntactic unit in which to encapsulate the type definition • A method of making type names and subprogram headers visible to clients, while hiding actual definitions • Some primitive operations must be built into the language processor Copyright © 2015 Pearson. All rights reserved. 1 -21
Design Issues • Can abstract types be parameterized? • What access controls are provided? • Is the specification of the type physically separate from its implementation? Copyright © 2015 Pearson. All rights reserved. 1 -22
Language Examples: C++ • Based on C struct type and Simula 67 classes • The class is the encapsulation device • A class is a type • All of the class instances of a class share a single copy of the member functions • Each instance of a class has its own copy of the class data members • Instances can be static, stack dynamic, or heap dynamic Copyright © 2015 Pearson. All rights reserved. 1 -23
Language Examples: C++ (continued) • Information Hiding – Private clause for hidden entities – Public clause for interface entities – Protected clause for inheritance (Chapter 12) Copyright © 2015 Pearson. All rights reserved. 1 -24
Language Examples: C++ (continued) • Constructors: – Functions to initialize the data members of instances (they do not create the objects) – 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 Copyright © 2015 Pearson. All rights reserved. 1 -25
Language Examples: C++ (continued) • 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 (~) Copyright © 2015 Pearson. All rights reserved. 1 -26
An Example in C++ class Stack { private: int *stack. Ptr, max. Len, top. Ptr; public: Stack() { // a constructor stack. Ptr = new int [100]; max. Len = 99; top. Ptr = -1; }; ~Stack () {delete [] stack. Ptr; }; void push (int number) { if (top. Sub == max. Len) cerr << ″Error in push - stack is fulln″; else stack. Ptr[++top. Sub] = number; }; void pop () {…}; int top () {…}; int empty () {…}; } Copyright © 2015 Pearson. All rights reserved. 1 -27
A Stack class header file // Stack. h - the header file for the Stack class #include <iostream. h> class Stack { private: //** These members are visible only to other //** members and friends (see Section 11. 6. 4) int *stack. Ptr; int max. Len; int top. Ptr; public: //** These members are visible to clients Stack(); //** A constructor ~Stack(); //** A destructor void push(int); void pop(); int top(); int empty(); } Copyright © 2015 Pearson. All rights reserved. 1 -28
The code file for Stack // Stack. cpp - the implementation file for the Stack class #include <iostream. h> #include "Stack. h" using std: : cout; Stack: : Stack() { //** A constructor stack. Ptr = new int [100]; max. Len = 99; top. Ptr = -1; } Stack: : ~Stack() {delete [] stack. Ptr; }; //** A destructor void Stack: : push(int number) { if (top. Ptr == max. Len) cerr << "Error in push--stack is fulln"; else stack. Ptr[++top. Ptr] = number; }. . . Copyright © 2015 Pearson. All rights reserved. 1 -29
Language Examples: C++ (continued) • Friend functions or classes - to provide access to private members to some unrelated units or functions – Necessary in C++ Copyright © 2015 Pearson. All rights reserved. 1 -30
Language Examples – Objective-C • Interface containers @interface class-name: parent-class { instance variable declarations } method prototypes @end • Implementation containers @implementation class-name method definitions @end • Classes are types Copyright © 2015 Pearson. All rights reserved. 1 -31
Language Examples – Objective-C (continued) • Method prototypes form (+ | -) (return-type) method-name [: (formal-parameters)]; - Plus indicates a class method - Minus indicates an instance method - The colon and the parentheses are not included when there are no parameters - Parameter list format is different - If there is one parameter (name is meth 1: ) -(void) meth 1: (int) x; - For two parameters -(int) meth 2: (int) x second: (float) y; - The name of the method is meth 2: : Copyright © 2015 Pearson. All rights reserved. 1 -32
Language Examples – Objective-C (continued) • Method call syntax [object-name method-name]; Examples: [my. Adder add 1: 7]; [my. Adder add 1: 7: 5: 3]; - For the method: -(int) meth 2: (int) x second: (float) y; the call would be like the following: [my. Object meth 2: 7 second: 3. 2]; Copyright © 2015 Pearson. All rights reserved. 1 -33
Language Examples – Objective-C (continued) • Constructors are called initializers – all they do is initialize variables – Initializers can have any name – they are always called explicitly – Initializers always return self • Objects are created by calling constructor alloc and the Adder *my. Adder = [[Adder alloc] init]; • All class instances are heap dynamic Copyright © 2015 Pearson. All rights reserved. 1 -34
Language Examples – Objective-C (continued) • To import standard prototypes (e. g. , i/o) #import <Foundation/Foundation. h> • The first thing a program must do is allocate and initialize a pool of storage for its data (pool’s variable is pool in this case) NSAutorelease. Pool * pool = [[NSAutorelease. Pool alloc] init]; • At the end of the program, the pool is released with: [pool drain]; Copyright © 2015 Pearson. All rights reserved. 1 -35
Language Examples – Objective-C (continued) • Information Hiding – The directives @private and @public are used to specify the access of instance variables. – The default access is protected (private in C++) – There is no way to restrict access to methods – The name of a getter method is always the name of the instance variable – The name of a setter method is always the word set with the capitalized variable’s name attached – If the getter and setter for a variable does not impose any constraints, they can be implicitly generated (called properties) Copyright © 2015 Pearson. All rights reserved. 1 -36
Language Examples – Objective-C (continued) // stack. m – interface and implementation for a simple stack #import <Foundation/Foundation. h> @interface Stack: NSObject { int stack. Array[100], stack. Ptr, max. Len, top. Sub; } -(void) push: (int) number; -(void) pop; -(int) top; -(int) empty; @end @implementation Stack -(Stack *) init. With { max. Len = 100; top. Sub = -1; stack. Ptr = stack. Array; return self; } Copyright © 2015 Pearson. All rights reserved. 1 -37
Language Examples – Objective-C (continued) // stack. m – continued -(void) push: (int) number { if (top. Sub == max. Len) NSLog(@″Error in push – stack is full″); else stack. Ptr[++top. Sub] = number; . . . } Copyright © 2015 Pearson. All rights reserved. 1 -38
Language Examples – Objective-C (continued) • An example use of stack. m – Placed in the @implementation of stack. m int main (int argc, char *argv[]) { int temp; NSAutorelease. Pool *pool = [[NSAutorelease. Pool alloc] init]; Stack *my. Stack = [[Stack alloc] init. With]; [my. Stack push: 5]; [my. Stack push: 3]; temp = [my. Stack top]; NSLog(@″Top element is: %i″, temp); [my. Stack pop]; temp = [my. Stack top]; NSLog(@″Top element is: %i″, temp); temp = [my. Stack top]; my. Stack pop]; [my. Stack release]; [pool drain]; return 0; } Copyright © 2015 Pearson. All rights reserved. 1 -39
Language Examples: Java • Similar to C++, except: – All user-defined types are classes – All objects are allocated from the heap and accessed through reference variables – Individual entities in classes have access control modifiers (private or public), rather than clauses - Implicit garbage collection of all objects – Java has a second scoping mechanism, package scope, which can be used in place of friends • All entities in all classes in a package that do not have access control modifiers are visible throughout the package Copyright © 2015 Pearson. All rights reserved. 1 -40
An Example in Java class Stack. Class { private: private int [] *stack. Ref; private int [] max. Len, top. Index; public Stack. Class() { // a constructor stack. Ref = new int [100]; max. Len = 99; top. Ptr = -1; }; public void push (int num) {…}; public void pop () {…}; public int top () {…}; public boolean empty () {…}; } Copyright © 2015 Pearson. All rights reserved. 1 -41
Language Examples: C# • Based on C++ and Java • Adds two access modifiers, internal and protected internal • All class instances are heap dynamic • Default constructors are available for all classes • Garbage collection is used for most heap objects, so destructors are rarely used • structs are lightweight classes that do not support inheritance Copyright © 2015 Pearson. All rights reserved. 1 -42
Language Examples: C# (continued) • Common solution to need for access to data members: accessor methods (getter and setter) • C# provides properties as a way of implementing getters and setters without requiring explicit method calls Copyright © 2015 Pearson. All rights reserved. 1 -43
C# Property Example public class Weather { public int Degree. Days { //** Degree. Days is a property get {return degree. Days; } set { if (value < 0 || value > 30) Console. Write. Line( "Value is out of range: {0}", value); else degree. Days = value; } } private int degree. Days; . . . }. . . Weather w = new Weather(); int degree. Days. Today, old. Degree. Days; . . . w. Degree. Days = degree. Days. Today; . . . old. Degree. Days = w. Degree. Days; Copyright © 2015 Pearson. All rights reserved. 1 -44
Abstract Data Types in Ruby • • • Encapsulation construct is the class Local variables have “normal” names Instance variable names begin with “at” signs (@) Class variable names begin with two “at” signs (@@) Instance methods have the syntax of Ruby functions (def … end) • Constructors are named initialize (only one per class)—implicitly called when new is called – If more constructors are needed, they must have different names and they must explicitly call new • Class members can be marked private or public, with public being the default • Classes are dynamic Copyright © 2015 Pearson. All rights reserved. 1 -45
Abstract Data Types in Ruby (continued) class Stack. Class { def initialize @stack. Ref = Array. new @max. Len = 100 @top. Index = -1 end def push(number) if @top. Index == @max. Len puts " Error in push – stack is full" else @top. Index = @top. Index + 1 @stack. Ref[@top. Index] = number end def pop … end def top … end def empty … end Copyright © 2015 Pearson. All rights reserved. 1 -46
Parameterized Abstract Data Types • Parameterized ADTs allow designing an ADT that can store any type elements – only an issue for static typed languages • Also known as generic classes • C++, Java 5. 0, and C# 2005 provide support for parameterized ADTs Copyright © 2015 Pearson. All rights reserved. 1 -47
Parameterized ADTs in C++ • Classes can be somewhat generic by writing parameterized constructor functions Stack (int size) { stk_ptr = new int [size]; max_len = size - 1; top = -1; }; A declaration of a stack object: Stack stk(150); Copyright © 2015 Pearson. All rights reserved. 1 -48
Parameterized ADTs in C++ (continued) • The stack element type can be parameterized by making the class a templated class template <class Type> class Stack { private: Type *stack. Ptr; const int max. Len; int top. Ptr; public: Stack() { // Constructor for 100 elements stack. Ptr = new Type[100]; max. Len = 99; top. Ptr = -1; } Stack(int size) { // Constructor for a given number stack. Ptr = new Type[size]; max. Len = size – 1; top. Sub = -1; }. . . } - Instantiation: Stack<int> my. Int. Stack; Copyright © 2015 Pearson. All rights reserved. 1 -49
Parameterized Classes in Java 5. 0 • Generic parameters must be classes • Most common generic types are the collection types, such as Linked. List and Array. List • Eliminate the need to cast objects that are removed • Eliminate the problem of having multiple types in a structure • Users can define generic classes • Generic collection classes cannot store primitives • Indexing is not supported • Example of the use of a predefined generic class: Array. List <Integer> my. Array = new Array. List <Integer> (); my. Array. add(0, 47); Copyright © 2015 Pearson. All rights reserved. // Put an element with subscript 0 in it 1 -50
Parameterized Classes in Java 5. 0 (continued) import java. util. *; public class Stack 2<T> { private Array. List<T> stack. Ref; private int max. Len; public Stack 2)( { stack. Ref = new Array. List<T> (); max. Len = 99; } public void push(T new. Value) { if (stack. Ref. size() == max. Len) System. out. println(" Error in push – stack is full"); else stack. Ref. add(new. Value); . . . } - Instantiation: Stack 2<string> my. Stack = new Stack 2<string> (); Copyright © 2015 Pearson. All rights reserved. 1 -51
Parameterized Classes in C# 2005 • Similar to those of Java 5. 0, except no wildcard classes • Predefined for Array, List, Stack, Queue, and Dictionary • Elements of parameterized structures can be accessed through indexing Copyright © 2015 Pearson. All rights reserved. 1 -52
Generics (Parameterized ADT) m CSE 4102 m m Classic Programming Problem q Develop Stack or List Code in C that Applies to a Single Type (e. g. , List of Deli. Items) q Need Same Code for Produce. Items, Meat. Items, etc. , Copy and Edit Original Code q Minimal Reuse, Error Prone, Time Consuming What do Generics Offer? q A Type-Parameterizable Class q Abstracts Similar Behavior into a Common Interface q Reusable and Consistent Class Illustrate via C++ 53
A Generic Stack Class template <class T> stack { private: T* st, CSE 4102 int top; int size; public: void stack(int x) {st = new T[x]; top = 0; size = x; } stack() {st = new T[100]; top = 0; size = 100; } ~stack() {delete st; } push(T entry) { st[top++] = entry; } }; main() { stack<int> S 1(10); // Creates int Stack with 10 Slots stack<char> S 2; // Creates char Stack with 100 Slots stack<Item> Item. DB(10000); // Stack of Grocery Items } 54
A Generic Set Class CSE 4102 template <class Item. Type> class Set { DLList<Item. Type>* _members; // Set Templates Uses Double-Linked List Template public: Set() { _members = new DLList<Item. Type>(); } void Add(Item. Type* member) {_members->queue(member); } void Remove(Item. Type* member) {_members->remove(member); } int Member(Item. Type* member) {return _members->is. Member(member); } int Null. Set(){return _members->is. Empty(); } } main() { Set<int> Int. Set; // Creates an Integer Set<Item> Item. DB; // Creates an Item Set } 55
Benefits of Generics m CSE 4102 m m Strong Promotion of Reuse q Develop Once, Use Often q stack and Set Examples Eliminate Errors and Inconsistencies Between Similar and Separate Classes q Simplifies Maintenance Problems q Focuses on Abstraction and Design Promotes Correctness and Consistent Program Behavior q Once Designed/Developed, Reused with Consistent Results q If Problems, Corrections in Single Location 56
Abstract Classes And Methods m CSE 4102 m Abstract Classes q Cannot be Instantiated q Can only be Subclassed q Keyword “abstract” before Keyword “class” is used to Define an Abstract Class q Example of an Abstract Class is Number in the java. lang Package Abstract Methods q Abstract Classes may contain Abstract Methods q This allows an Abstract Class to Provide all its Subclasses with the Method Declarations for all the Methods 57
A Sample Abstract Class abstract class Item protected String CSE 4102 protected int protected double public abstract public { UPC, Name; Quantity; Retail. Cost, Whole. Cost; Item() {. . . }; void finalize(); boolean Modify_Inventory(int Delta); Get_In. Stock_Amt() {. . . }; Compute_Item_Profit() {. . . }; public int public double protected boolean Modify_Whole. Sale(double New. Price); {. . . }; }; 58
Another Abstract Class and Methods abstract class Graphics. Object{ int x, y; void move. To(int x 1, y 1) {. . . } CSE 4102 abstract void draw(); } class Circle extends Graphics. Object{ void draw() {. . . } } class Rectangle extends Graphics. Object{ void draw() {. . . } 59
Interfaces in Java m CSE 4102 m m Design-Level Multiple Inheritance Java Interface q Set of Methods (no Implementations) q Set (Possibly Empty) of Constant Values Interfaces Utilized Extensively Throughout Java APIs to Acquire and Pass on Functionality q Threads in Java - Multiple Concurrent Tasks q Subclassing from Thread Class (java. lang API) q Implementing an Interface of Runnable Class 60
A Sample Interface in Java Teaching CSE 4102 Student / Under. Graduate Employee | Faculty interface Teaching { int NUMSTUDENTS = 25; void recordgrade(Undergrad u, int score); void advise(Undergrad u); . . . etc. . . } class Graduate extends Student implements Teaching{. . . } class Faculty extends Employee implements Teaching{. . . } recordgrade() Different for Graduate & Faculty 61
Quasi Generics in Java CSE 4102 class Set implements Coll{ void add(Object obj){. . . } void delete(Object obj){. . . } } interface Coll { int MAXIMUM = 500; void add(Object obj); void delete(Object obj); Object find(Object obj); int current. Count(); } class Queue implements Coll{ void add(Object obj){. . . } void delete(Object obj){. . . } } 62
Encapsulation Constructs • Large programs have two special needs: – Some means of organization, other than simply division into subprograms – 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) • Such collections are called encapsulation Copyright © 2015 Pearson. All rights reserved. 1 -63
Nested Subprograms • Organizing programs by nesting subprogram definitions inside the logically larger subprograms that use them • Nested subprograms are supported in Python, Java. Script, and Ruby Copyright © 2015 Pearson. All rights reserved. 1 -64
Encapsulation in C • Files containing one or more subprograms can be independently compiled • The interface is placed in a header file • Problem 1: the linker does not check types between a header and associated implementation • Problem 2: the inherent problems with pointers • #include preprocessor specification – used to include header files in applications Copyright © 2015 Pearson. All rights reserved. 1 -65
Encapsulation in C++ • Can define header and code files, similar to those of C • Or, classes can be used for encapsulation – The class is used as the interface (prototypes) – The member definitions are defined in a separate file • Friends provide a way to grant access to private members of a class Copyright © 2015 Pearson. All rights reserved. 1 -66
C# Assemblies • A collection of files that appears to application programs to be a single dynamic link library or executable • Each file contains a module that can be separately compiled • A DLL is a collection of classes and methods that are individually linked to an executing program • C# has an access modifier called internal; an internal member of a class is visible to all classes in the assembly in which it appears Copyright © 2015 Pearson. All rights reserved. 1 -67
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 Copyright © 2015 Pearson. All rights reserved. 1 -68
Naming Encapsulations (continued) • Java Packages – Packages can contain more than one class definition; classes in a package are partial friends – Clients of a package can use fully qualified name or use the import declaration Copyright © 2015 Pearson. All rights reserved. 1 -69
Naming Encapsulations (continued) • Ruby Modules: - Ruby classes are name encapsulations, but Ruby also has modules - Typically encapsulate collections of constants and methods - Modules cannot be instantiated or subclassed, and they cannot define variables - Methods defined in a module must include the module’s name - Access to the contents of a module is requested with the require method Copyright © 2015 Pearson. All rights reserved. 1 -70
Summary • The concept of ADTs and their use in program design was a milestone in the development of languages • Two primary features of ADTs are the packaging of data with their associated operations and information hiding • Ada provides packages that simulate ADTs • C++ data abstraction is provided by classes • Java’s data abstraction is similar to C++ • C++, Java 5. 0, and C# 2005 support parameterized ADTs • C++, C#, Java, and Ruby provide naming encapsulations Copyright © 2015 Pearson. All rights reserved. 1 -71
- Slides: 71