Abstraktion och modellering VT 2015

Transcription

1 TDDC74 Programmering: Abstraktion och modellering VT 2015 Johannes Schmidt Institutionen för datavetenskap Linköpings universitet

2 Lecture 9 Mutable structres, ADTs, OOP Abstract data types: queue, stack Mutable pairs, lists: singly / doubly linked list Object Oriented Programming (OOP) in Racket SICP-Book chapter: 3

3 An abstract data type: Stack Think of a stack as a pile of books (items): TOS: Top Of Stack. Insertion (push) and extraction (pop) only at the TOS. LIFO = last in, first out

4 An abstract data type: Stack ADT Stack Methods: push: put a given item on the stack. This item is then the new TOS. pop: remove the TOS-item and return it. Optional methods: size: determine the number of elements currently in the stack. empty?: check whether the stack is empty. peek: return the TOS-item without removing it.

5 An abstract data type: Queue Think of a queue as a queue of people (items): Insertion (enqueue) at the rear, extraction (dequeue) at the front. FIFO = first in, first out

6 An abstract data type: Queue ADT Queue Methods: enqueue: put a given item into the queue, at the rear. dequeue: remove an item from the queue, at the front. Optional methods: size: determine the number of elements currently in the queue. empty?: check whether the queue is empty. peek: return the front-item without removing it.

7 How to implement a stack, a queue? Singly linked list Doubly linked list?

8 Doubly linked list A doubly linked list with insertion and extraction at both ends can be used to implement both, stack and queue push pop enqueue dequeue - insert at front - extract at front - insert at rear - extract at front

9 How to implement singly / doubly linked lists? Singly linked list Easy: take on ordinary list Doubly linked list Easy: create a triple-object with selectors left, middle, right E.g. (define (make-triple left middle right) (mcons left (mcons middle right)))

10 Object Oriented Programming Is a programming paradigm. Idea: every problem can be described by objects and their interactions / relations. This helps creating abstractions and achieving encapsulation. Therefore: in order to solve a problem, break it down into subproblems, by identifying objects and how they interact with and relate to each other.

11 OOP Example Game Pac-Man Scenario: Pac-Man goes through a labyrinth, eats pellets and has to avoid being eaten/attacked by enemies. Identify Objects: Pac-Man Pellet Enemy Power pellet Source:

12 OOP Example Relations between Objects: Pac-Man eats Pellets Enemy eats/attacks Pac-Man Pac-Man eats Power pellet Pac-Man eats Enemy if eaten recently Power pellet Source:

13 Object Oriented Programming Is a programming paradigm. Idea: every problem can be described by objects and their interactions / relations. Relations between objects indicate what different properties the different objects should have. These properties are realized via fields (variables/data) and methods (procedures): Every object has its own fields and methods!

14 OOP Example Some fields of some Objects: Pac-Man: Lifes (0-3) Score ( ) State: recently Power pellet eaten? Enemy: Color State: currently eatable or not? Direction Speed Source:

15 OOP Example Some methods of some Objects: Pac-Man: (eat-enemy enemy) (reduce-life amount) (eat-pellet pellet) (die) Enemy: (eat-pac-man) (change-eatable-state value) (speed-up) (die) Source:

16 OOP Example Game Pac-Man Observation: some objects will occur just once, others several times Occurrences of Objects: 1x Pac-Man Nx Pellet 4x Enemy 4x Power pellet Source:

17 OOP Example Game Pac-Man Observation: some objects will occur just once, others several times Occurrences of Objects: 1x Pac-Man Nx Pellet 4x Enemy 4x Power pellet Solution: Classes! Source:

18 OOP - Classes A Class can be considered as a model for objects that share the same properties, but are still different individuals. If we have a class definition, we can then create an object from that class. This process is called instantiating. For this purpose every class provides a constructor.

19 OOP Example Game Pac-Man Classes for Pac-Man: Pac-Man Pellet Enemy Power-pellet Then instantiate One object of Pac-Man Many objects of Pellet Four objects of Enemy Four objects of Power-pellet Source:

20 OOP - Inheritance A Class can be considered as a model for objects that share the same properties, but are still different individuals. What if we have similar classes that share a lot of common properties but are not exactly the same? Solution: We can derive or inherit a class from another. Via Inheritance we obtain a derived class, or a subclass. Think of this as taking a copy of a class, and then modifying this copy according to our needs.

21 OOP Example Game Pac-Man Similar classes for Pac-Man: Pellet Power-pellet For instance make Power-pellet a subclass of Pellet, i.e. treat a Power-pellet as a special case of a Pellet. Alternatively: Have a common superclass, call it General-pellet. Then derive once an Ordinarypellet and once a Power-pellet. Source:

22 OOP in Racket - simple (define (make-pac-man lifes score pp-eaten) ; three fields (define (dispatch message. args) ; define different methods (cond ((eq? message 'eat-enemy) (if pp-eaten (void) 'not-possible)) dispatch) ((eq? message 'reduce-life) (set! lifes (- lifes (car args)))) ((eq? message 'eat-pellet) (set! score (+ score 1))) ((eq? message 'die) (void)) ; details to be implemented ; details to be implemented ((eq? message 'say-hello) (printf "Hi I am a happy pac-man with ~a lifes\n" lifes)) (else '(unkown message))))

23 OOP in Racket - simple (define (make-pac-man lifes score pp-eaten) ; three fields (define (dispatch message. args) ; define different methods (cond ((eq? message 'eat-enemy) (if pp-eaten (void) 'not-possible)) dispatch) ; create a Pac-Man: instantiate ; details to be implemented (define my-pac-man (make-pac-man 3 0 #f)) ((eq? message 'reduce-life) ; call some methods (set! lifes (- lifes (car(my-pac-man args)))) 'say-hello) (my-pac-man 'reduce-life 1) ((eq? message 'eat-pellet) (my-pac-man 'say-hello) (set! score (+ score 1))) ((eq? message 'die) Output: (void)) Hi I am a ; happy details pac-man to be with implemented 3 lifes Hi I am a happy pac-man with 2 lifes ((eq? message 'say-hello) (printf "Hi I am a happy pac-man with ~a lifes\n" lifes)) (else '(unkown message))))

24 OOP in Racket (define Pac-Man% (class object% ; fields (variables/data) (init-field lifes score pp-eaten) (super-new) ; superclass initialization (define/public (eat-enemy enemy) ; method (if pp-eaten (void) ; details to be implemented 'not-possible)) (define/public (reduce-life amount) (set! lifes (- lifes amount))) (define/public (eat-pellet pellet) (set! score (+ score 1))) (define/public (die) (void)) ; method ; method ; method ; details to be implemented (define/public (say-hello) (printf "Hi I am a happy pac-man with ~a lifes\n" lifes))))

25 OOP in Racket (define Pac-Man% (class object% ; fields (variables/data) (init-field lifes score pp-eaten) (super-new) ; superclass ; create initialization a Pac-Man: instantiate (define my-pac-man (make-object Pac-Man% 3 0 #f)) (define/public (eat-enemy enemy) ; method (if pp-eaten ; call some methods (void) ; details (send to my-pac-man be implemented say-hello) 'not-possible)) (send my-pac-man reduce-life 1) (define/public (reduce-life(send amount) my-pac-man ; method say-hello) (set! lifes (- lifes amount))) Output: (define/public (eat-pellet pellet) Hi I am a happy ; method pac-man with 3 lifes (set! score (+ score 1))) Hi I am a happy pac-man with 2 lifes (define/public (die) (void)) ; method ; details to be implemented (define/public (say-hello) (printf "Hi I am a happy pac-man with ~a lifes\n" lifes))))

26 OOP in Racket - Inheritance (define General-pellet% (class object% ; fields (variables/data) (init-field color position) (super-new) ; superclass initialization (define/public (get-type) ; method 'general))) (define Ordinary-pellet% (class General-pellet% (super-new) ; superclass initialization (define/override (get-type) ; method 'ordinary))) (define Power-pellet% (class General-pellet% (super-new) ; superclass initialization (define/override (get-type) ; method 'power)))

27 OOP in Racket - Inheritance (define General-pellet% (class object% We inherit from object% This is a special inbuilt base class ; fields (variables/data) (init-field color position) (super-new) ; superclass initialization (define/public (get-type) ; method 'general))) (define Ordinary-pellet% (class General-pellet% We inherit from General-pellet% (super-new) ; superclass initialization (define/override (get-type) ; method 'ordinary))) (define Power-pellet% (class General-pellet% And here too (super-new) ; superclass initialization (define/override (get-type) ; method 'power)))

28 OOP in Racket - Overriding (define General-pellet% (class object% ; fields (variables/data) (init-field color position) (super-new) ; superclass initialization (define/public (get-type) ; method 'general))) (define Ordinary-pellet% We inherit ALL fields and methods. (class General-pellet% (super-new) That ; superclass is: initialization (define/override (get-type) - no need to redefine ; fields method or methods 'ordinary))) - if we want to change a method, we need to explicitly override (redefine) it (define Power-pellet% (class General-pellet% (super-new) ; superclass initialization (define/override (get-type) ; method 'power)))

29 OOP in Racket - Instantiation (make-object <Class> <list of init-values>) (define my-pac-man (make-object Pac-Man% 3 0 #f)) ; Alternatively: (new <Class> [varname1 value1] [varname2 value2]...) (define my-pac-man (new Pac-Man% [lifes 3] [score 0] [pp-eaten #f]))

30 OOP in Racket calling methods From inside the class definition you call methods as usual. From outside special syntax is provided: (send <object> <method-name> <list of parameters>) ; e.g.: (send my-pac-man say-hello) (send my-pac-man reduce-life 1) (send my-pac-man say-hello)

31 OOP in Racket field vs init-field (define Pac-Man% (class object% ; init-fields, i.e. values MUST ; be provided during instantiation (init-field lifes score pp-eaten) ; ordinary fields, i.e. values must be provided ; right here (field [color 'red] [more-stuff 'hmblhmbl])...

32 OOP in Racket accessing fields From inside the class definition you access fields as usual variables. From outside special syntax is provided: (get-field <field-name> <object-name>) (set-field! <field-name> <object-name> value) E.g. (define my-pac-man (make-object Pac-Man% 3 0 #f)) (get-field color my-pac-man) (set-field! color my-pac-man 'green) But: avoid setting fields this way. Better provide your own methods to change the values of fields.

33 OOP in Racket Visibility public vs private (define Pac-Man% (class object% ; public fields (visible/accessible from outside) (init-field lifes score pp-eaten) (field [color 'red] [more-stuff 'hmblhmbl]) ; private fields (not visible from outside) (define internal-value 11439) ; public method (visible/accessible from outside) (define/public (eat-enemy enemy) ; method (if pp-eaten (void) ; details to be implemented 'not-possible)) ; private method (not visible from outside) (define (do-some-stuff parameter1)...)

34 OOP notions object, class field, method inherit, derive, extend subclass, superclass override

35 OOP purpose Remember: use OOP in order to create abstractions and to achieve encapsulation (hide implementation details). Therefore: keep as much as possible private, so it is not visible to the outside. Expose to the outside only what is absolutely necessary. Provide public methods to manipulate variables/fields, do not set them directly.