Object-Oriented Software Construction

Transcription

1 1 Object-Oriented Software Construction Bertrand Meyer

2 Reading assignment 2 OOSC2 Chapter 10: Genericity

3 3 Lecture 4: Abstract Data Types

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

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

6 Finding the structure 6 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

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

8 Object technology: A first definition 8 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.

9 The O-O designer s motto 9 Ask NOT first WHAT the system does: Ask WHAT it does it TO!

10 Issues of object-oriented design 10 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.

11 Description of objects 11 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

12 The theoretical basis 12 The main issue: How to describe program objects (data structures: Completely Unambiguously Without overspecifying? (Remember information hiding

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

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

15 Stack: An abstract data type 15 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]

16 Using functions to model operations 16, = s x s

17 Reminder: Partial functions 17 A partial function, identified here by, is a function that may not be defined for all possible arguments. Example from elementary mathematics: inverse: R R, such that inverse (x = 1 / x

18 The STACK ADT (cont d 18 Preconditions: s: STACK [G] require not empty (s item (s: STACK [G] require not empty (s Axioms: For all x: G, s: STACK [G] item (s, x = x s, x = s empty (new (or: empty (new = True not empty (s, x, = s x s (or: empty (s, x = False

19 Exercises 19 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.

20 Formal stack expressions 20 value = item (put (new, x8, x7, x6, item (new, x5, x4, x2, x1

21 Expressed differently 21 value = item (new, x8, x7, x6, item (new, x5, x4, x2, x1 s1 = new s2 = s1, x8, x7, x6 s3 = s2 s4 = new s5 = s4, x5, x4 s6 = s5 y1 = item (s6 s7 = s3, y1 s8 = s7, x2 s9 = s8 s10 = s9, x1 s11 = s10 value = item (s11

22 Expression reduction (1/10 22 value = item ( x7 x8, x1 x6 new, x8, x7, x6, item ( new, x5, x4, x2 x4 x5 Stack 1 Stack 2

23 Expression reduction (2/10 23 put x6 remove value = item ( x7 x7 x7 x4 x8 x8 x8 x5 Stack 1 Stack 2 new, x8, x7, x6, item ( new, x5, x4, x2, x1

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

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

26 Expression reduction (5/10 26 value = item ( x7 x8, x1 Stack 1 item new, x8, x7, x6, item ( new, x5, x4, x2 x5 Stack 2

27 Expression reduction (6/10 27 value = item ( x7 x8, x1 Stack 1 new, x8, x7, x6, item ( new, x5, x4, x2 x5 Stack 2

28 Expression reduction (7/10 28 value = item (, x1 new, x8, x7, x6, item ( new, x5, x4, x2 x5 x7 x8 Stack 3

29 Expression reduction (8/10 put x1 remove 29 value = item (, x1 x5 x7 x8 new, x8, x7, x6, item ( new, x5, x4, x2 x5 x7 x8 Stack 3 x5 x7 x8

30 Expression reduction (9/10 30 value = item (, x1 x5 x7 x8 Stack 3 item new, x8, x7, x6, item ( new, x5, x4, x2

31 Expression reduction (10/10 31 value = item ( value = x5, x1 new, x8, x7, x6, item ( new, x5, x4, x2 x5 x7 x8 Stack 3

32 Expressed differently 32 value = item (new, x8, x7, x6, item (new, x5, x4, x2, x1 s1 = new s2 = s1, x8, x7, x6 s3 = s2 s4 = new s5 = s4, x5, x4 s6 = s5 y1 = item (s6 s7 = s3, y1 s8 = s7, x2 s9 = s8 s10 = s9, x1 s11 = s10 value = item (s11

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

34 Sufficient completeness 34 Three forms of functions in the specification of an ADT T: Creators: OTHER T e.g. new Queries: T... OTHER Commands: T... T e.g. item, empty 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 a form not involving T

35 Stack: An abstract data type 35 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]

36 ADT and software architecture 36 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.

37 Implementing an ADT 37 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.

38 A choice of stack representation 38 (array_up capacity count Push operation: count := count + 1 representation [count] := x representation

39 Application to information hiding 39 Public part: ADT specification (E1 Secret part: Choice of representation (E2 Implementation of functions by features (E3

40 Object technology: A first definition 40 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.

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

42 Classes: The fundamental structure 42 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.

43 Class relations 43 Two relations: Client Heir

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

45 A very deferred class 45 deferred class COUNTER feature item: INTEGER is deferred end -- Counter value up is -- Increase item by 1. deferred ensure item = old item + 1 end down is -- Decrease item by 1. deferred ensure item = old item 1 invariant end end item >= 0

46 46 End of lecture 4