1 / 46

Object-Oriented Software Construction

Object-Oriented Software Construction. Bertrand Meyer. Reading assignment. OOSC2 Chapter 10: Genericity. Lecture 4: Abstract Data Types. Abstract Data Types (ADT). Why use the objects? The need for data abstraction Moving away from the physical representation

raymondbrooks
Télécharger la présentation

Object-Oriented Software Construction

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Object-Oriented Software Construction Bertrand Meyer OOSC - Lecture 4

  2. Reading assignment • OOSC2 • Chapter 10: Genericity OOSC - Lecture 4

  3. Lecture 4: Abstract Data Types OOSC - Lecture 4

  4. Abstract Data Types (ADT) • Why use the objects? • The need for data abstraction • Moving away from the physical representation • Abstract data type specifications • Applications to software design OOSC - Lecture 4

  5. The first step • A system performs certain actions on certain data. • Basic duality: • Functions [or: Operations, Actions] • Objects [or: Data] Action Object Processor OOSC - Lecture 4

  6. Finding the structure • The structure of the system may be deduced from an analysis of the functions (1) or the objects (2). • Resulting analysis and design method: • Process-based decomposition: classical (routines) • Object-oriented decomposition OOSC - Lecture 4

  7. Arguments for using objects • Reusability: Need to reuse whole data structures, not just operations • Extendibility, Continuity: Objects remain more stable over time. Employee information Produce Paychecks Paychecks Hours worked OOSC - Lecture 4

  8. Object technology: A first definition • Object-oriented software construction is the approach to system structuring that bases the architecture of software systems on the types of objects they manipulate — not on “the” function they achieve. OOSC - Lecture 4

  9. The O-O designer’s motto • Ask NOT first WHAT the system does: Ask WHAT it does it TO! OOSC - Lecture 4

  10. Issues of object-oriented design • How to find the object types. • How to describe the object types. • How to describe the relations and commonalities between object types. • How to use object types to structure programs. OOSC - Lecture 4

  11. Description of objects • Consider not a single object but a type of objects with similar properties. • Define each type of objects not by the objects’ physical representation but by their behavior: the services (FEATURES) they offer to the rest of the world. • External, not internal view: ABSTRACT DATA TYPES OOSC - Lecture 4

  12. The theoretical basis • The main issue: How to describe program objects (data structures): • Completely • Unambiguously • Without overspecifying? • (Remember information hiding) OOSC - Lecture 4

  13. A stack, concrete object capacity “Push” operation: count := count + 1 count (array_up) representation [count] := x representation “Push” operation: representation [free] := x (array_down) free := free - 1 free 1 representation “Push” operation: new new (n) item previous n n.item := x item previous n.previous := last (linked) previous head := n item OOSC - Lecture 4

  14. A stack, concrete object capacity “Push” operation: count := count + 1 count (array_up) representation [count] := x representation “Push” operation: representation [free] := x (array_down) free := free - 1 free 1 representation “Push” operation: new new (n) item previous n n.item := x item previous n.previous := last (linked) previous head := n item OOSC - Lecture 4

  15. Stack: An abstract data type • Types: • STACK [G] -- G: Formal generic parameter • Functions (Operations): • put: STACK [G] GSTACK [G] • remove: STACK [G] STACK [G] • item: STACK [G] G • empty: STACK [G] BOOLEAN • new: STACK [G] OOSC - Lecture 4

  16. Using functions to model operations ( ) put , = s x s’ OOSC - Lecture 4

  17. Reminder: Partial functions • A partial function, identified here by , is a function that may not be defined for all possible arguments. • Example from elementary mathematics: • inverse: , such that inverse(x) = 1 / x OOSC - Lecture 4

  18. The STACK ADT (cont’d) • Preconditions: • remove (s: STACK [G]) require notempty (s) • item (s: STACK [G]) require notempty (s) • Axioms: For all x: G, s: STACK [G] • item(put(s, x)) = x • remove(put(s, x)) = s • empty(new) (or:empty(new) = True) • notempty (put (s, x)) (or: empty (put (s, x)) =False) put ( , ) = s x s’ OOSC - Lecture 4

  19. Exercises • Adapt the preceding specification of stacks (LIFO, Last-In First-Out) to describe queues instead (FIFO). • Adapt the preceding specification of stacks to account for bounded stacks, of maximum size capacity. • Hint: put becomes a partial function. OOSC - Lecture 4

  20. Formal stack expressions value = item (remove (put (remove (put (put (remove (put (put (put (new, x8), x7), x6)), item (remove (put (put (new, x5), x4)))), x2)), x1))) OOSC - Lecture 4

  21. Expressed differently value = item (remove (put (remove (put (put (remove (put (put (put (new, x8), x7), x6)), item (remove (put (put (new, x5), x4)))), x2)), x1))) • s1 = new • s2 = put (put (put (s1, x8), x7), x6) • s3 = remove (s2) • s4 = new • s5 = put (put (s4, x5), x4) • s6 = remove (s5) • y1 = item (s6) • s7 = put (s3, y1) • s8 = put (s7, x2) • s9 = remove (s8) • s10 = put (s9, x1) • s11 = remove (s10) • value = item (s11) OOSC - Lecture 4

  22. Expression reduction (1/10) x6 value = item ( remove ( put ( remove ( put ( put ( remove ( put (put (put (new, x8), x7), x6) ) , item ( remove ( put (put (new, x5), x4) ) ) ) , x2) ) , x1) ) ) x4 x7 x8 x5 Stack 1 Stack 2 OOSC - Lecture 4

  23. Expression reduction (2/10) put x6 remove value = item ( remove ( put ( remove ( put ( put ( remove ( put (put (put (new, x8), x7), x6) ) , item ( remove ( put (put (new, x5), x4) ) ) ) , x2) ) , x1) ) ) x4 x7 x7 x7 x8 x8 x8 x5 Stack 1 Stack 2 OOSC - Lecture 4

  24. Expression reduction (3/10) put put x2 x2 remove remove value = item ( remove ( put ( remove ( put ( put ( remove( put(put (put (new, x8), x7), x6) ) , item ( remove( put(put (new, x5), x4) ) ) ) , x2) ) , x1) ) ) x4 x7 x7 x7 x7 x7 x7 x8 x8 x8 x8 x8 x8 x5 Stack 1 Stack 2 OOSC - Lecture 4

  25. Expression reduction (4/10) value = item ( remove ( put ( remove ( put ( put ( remove ( put (put (put (new, x8), x7), x6) ) , item ( remove ( put (put (new, x5), x4) ) ) ) , x2) ) , x1) ) ) put x4 remove x7 x7 x8 x8 x5 x5 x5 Stack 1 Stack 2 OOSC - Lecture 4

  26. Expression reduction (5/10) value=item ( remove( put( remove ( put ( put ( remove ( put (put (put (new, x8), x7), x6) ) , item ( remove ( put (put (new, x5), x4) ) ) ) , x2) ) ,x1) ) ) x7 x7 item x8 x8 x5 Stack 1 Stack 2 OOSC - Lecture 4

  27. Expression reduction (6/10) value=item ( remove( put( remove ( put ( put ( remove ( put (put (put (new, x8), x7), x6) ) , item ( remove ( put (put (new, x5), x4) ) ) ) , x2) ) ,x1) ) ) x7 x7 x8 x8 x5 Stack 1 Stack 2 OOSC - Lecture 4

  28. Expression reduction (7/10) value=item ( remove( put( remove ( put ( put ( remove ( put (put (put (new, x8), x7), x6) ) , item ( remove ( put (put (new, x5), x4) ) ) ) , x2) ) ,x1) ) ) x5 x7 x7 x8 x8 Stack 3 OOSC - Lecture 4

  29. Expression reduction (8/10) put x1 remove value=item ( remove ( put ( remove ( put ( put ( remove ( put (put (put (new, x8), x7), x6) ) , item ( remove ( put (put (new, x5), x4) ) ) ) , x2) ) , x1) ) ) x5 x5 x5 x7 x7 x7 x7 x7 x7 x8 x8 x8 x8 x8 x8 Stack 3 OOSC - Lecture 4

  30. Expression reduction (9/10) item value=item ( remove ( put ( remove ( put ( put ( remove ( put (put (put (new, x8), x7), x6) ) , item ( remove ( put (put (new, x5), x4) ) ) ) , x2) ) , x1) ) ) x5 x7 x7 x8 x8 Stack 3 OOSC - Lecture 4

  31. Expression reduction (10/10) value=item( remove ( put ( remove ( put ( put ( remove ( put (put (put (new, x8), x7),x6) ) , item ( remove ( put (put (new,x5), x4) ) ) ) , x2) ) , x1) ) ) value = x5 x5 x7 x7 x8 x8 Stack 3 OOSC - Lecture 4

  32. Expressed differently value = item (remove (put (remove (put (put (remove (put (put (put (new, x8), x7), x6)), item (remove (put (put (new, x5), x4)))), x2)), x1))) • s1 = new • s2 = put (put (put (s1, x8), x7), x6) • s3 = remove (s2) • s4 = new • s5 = put (put (s4, x5), x4) • s6 = remove (s5) • y1 = item (s6) • s7 = put (s3, y1) • s8 = put (s7, x2) • s9 = remove (s8) • s10 = put (s9, x1) • s11 = remove (s10) • value = item (s11) OOSC - Lecture 4

  33. An operational view of the expression x6 value = item (remove (put (remove (put (put (remove (put (put (put (new, x8), x7), x6)), item (remove (put (put (new, x5), x4)))), x2)), x1))) x7 x7 x4 y1 x8 x8 x5 x5 s1 s2 s3 s4 s5 s6 (empty) (empty) x2 x1 x5 x5 x5 x7 x7 x7 x8 x8 x8 s7 (s9, s11) s8 s10 OOSC - Lecture 4

  34. Sufficient completeness • Three forms of functions in the specification of an ADT T: • Creators:OTHERTe.g. new • Queries:T...  OTHER e.g. item, empty • Commands: T... T e.g.put, remove • Sufficiently complete specification: a “Query Expression” of the form: f (...) where f is a query, may be reduced through application of the axioms to aformnotinvolvingT OOSC - Lecture 4

  35. Stack: An abstract data type • Types: • STACK [G] -- G: Formal generic parameter • Functions (Operations): • put: STACK [G] GSTACK [G] • remove: STACK [G] STACK [G] • item: STACK [G] G • empty: STACK [G] BOOLEAN • new: STACK [G] OOSC - Lecture 4

  36. ADT and software architecture • Abstract data types provide an ideal basis for modularizing software. • Identify every module with an implementation of an abstract data type, i.e. the description of a set of objects with a common interface. • The interface is defined by a set of operations (implementing the functions of the ADT) constrained by abstract properties (the axioms and preconditions). • The module consists of a representation for the abstract data type and an implementation for each of the operations. Auxiliary operations may also be included. OOSC - Lecture 4

  37. Implementing an ADT • Three components: (E1) The ADT’s specification: functions, axioms, preconditions. (Example: stacks.) (E2) Some representation choice.(Example: <representation, count>.) (E3) A set of subprograms (routines) and attributes, each implementing one of the functions of the ADT specification (E1) in terms of the chosen representation (E2).(Example: routines put, remove, item, empty, new.) OOSC - Lecture 4

  38. A choice of stack representation “Push” operation: count := count + 1 representation [count] := x capacity count (array_up) representation OOSC - Lecture 4

  39. Application to information hiding Public part: ADT specification (E1) Secret part: • Choice of representation (E2) • Implementation of functions by features (E3) OOSC - Lecture 4

  40. Object technology: A first definition • Object-oriented software construction is the approach to system structuring that bases the architecture of software systems on the types of objects they manipulate — not on “the” function they achieve. OOSC - Lecture 4

  41. Object technology: More precise definition • Object-oriented software construction is the construction of software systems as structured collections of (possibly partial) abstract data type implementations. OOSC - Lecture 4

  42. Classes: The fundamental structure • Merging of the notions of module and type: • Module = Unit of decomposition: set of services • Type = Description of a set of run-time objects (“instances” of the type) • The connection: • The services offered by the class, viewed as a module, are the operations available on the instances of the class, viewed as a type. OOSC - Lecture 4

  43. Class relations • Two relations: • Client • Heir OOSC - Lecture 4

  44. Overall system structure space_before space_after add_space_before add_space_after CHUNK FEATURES QUERIES COMMANDS length set_font add_word font hyphenate_on FIGURE remove_word hyphenate_off PARAGRAPH WORD justify word_count unjustify justified? Inheritance Client OOSC - Lecture 4

  45. A very deferred class deferred classCOUNTER feature item: INTEGERis deferred end-- Counter value upis-- Increase item by 1. deferred ensureitem = olditem + 1end downis-- Decrease item by 1. deferred ensureitem = olditem – 1end invariant item >= 0 end OOSC - Lecture 4

  46. End of lecture 4 OOSC - Lecture 4

More Related