Object Oriented Programming (OOP)

Transcription

1 Object Oriented Programming (OOP) o New programming paradigm o Actions Objects o Objects Actions o Object-oriented = Objects + Classes + Inheritance Imperative programming o OOP (Object-Oriented Programming) related o Local state, delegation, inheritance o History (Norvig,465): Algol 60 SIMULA o Lisp extensions: o Smalltalk (69) o Flavors (79) o New Flavors (81) o Common Loops (88) o CLOS (91): standard

2 LISP world Smalltalk LAMBDA Flavors History Algol60 multiple inheritance method combination Simula Classes single inheritance Dahl 1966 Nygaard Kay 1969 Goldberg Ingalls Steele 1976 Cannon Weinreb 1979 New Flavors generic functions Symbolics 1981 CommonLoops Oaklisp CLOS multimethods C++ Eiffel JAVA Xerox 1982 AT&T Bell labs 1986 Meyer 1988 Lang 1988 Perlmutter Steele 1991 AOP vs. OOP (Shoham) Basic unit OOP Object (passive) AOP Agent (active) State Computation without restriction Message passing, methods belief, commitment, competence, preferences, Message passing, methods Type of messages Message restrictions without restriction no Inform, request, offer, promise, reject, Honesty, consistency, rationality,

3 Nomenclature o Object: encapsulated local state and behavior o Class: describes similar objects with the same behavior and structure. o Instance: object belonging to a class. o Class Variable: variable shared by all the members of a class. o Instance Variable: encapsulated variable of an object. o Generic Function: its behavior depends on the types or classes of the arguments. Nomenclature o Message: Action name. Equivalent to a generic function. o Method: Specialization of a generic function. o Delegation: an object passes a task to another object. o Multimethod: method with more than one argument o Inheritance: to define new classes that are a specialization of a more general one. o Multiple inheritance: from more than one father class.

4 Object-Oriented Style o Example: Bank account class o Local state and functions o Instance variables: balance, interest rate o Messages and methods: withdraw, deposit, balance, name, interest o It is not possible to manipulate the variables in a closure using CommonLisp. o INSPECT is implementation dependent Object-Oriented Style (defun new-account (name &optional (balance 0.00) (interest-rate.06)) new account with the following messages:" #'(lambda (message) (case message (withdraw #'(lambda (amt) (if (<= amt balance) (decf balance amt) 'insufficient-funds))) (deposit #'(lambda (amt) (incf balance amt))) (balance #'(lambda () balance)) (name #'(lambda () name)) (interest #'(lambda () (incf balance (* interest-rate balance)))))))

5 SEND o Send function (Flavors) implements the control of objects. (defun get-method (object message) Returns the method for the given message" (funcall object message)) (defun send (object message &rest args) Applies the method for the message with the arguments (apply (get-method object message) args)) SEND o Execution examples > (setf acct (new-account "J. Random Customer" )) #<CLOSURE > > (send acct 'withdraw ) > (send acct 'deposit ) > (send acct 'name) "J. Random Customer" > (send acct 'balance)

6 Generic functions o The syntax of send is not useful. We are interested in expressions of the following type: o (mapcar 'balance accounts) o Using messages: o (mapcar #'(lambda (acct) (send acct 'balance)) accounts) o Generic functions will find the correct method of an object, specialized on a message type. o (defun withdraw (object &rest args) withdraw is a generic function over objects." (apply (get-method object 'withdraw) args)) o We can write: o (withdraw acct x) o Instead of: o (send acct 'withdraw x) Classes o Using Macros o Easier read and write object-oriented code o Create a new class o Methods o Generic functions for each message o Class variables o Instance variables

7 Classes (define-class account (name &optional (balance 0)) ((interest-rate.06)) (withdraw (amt) (if (<= amt balance (decf balance amt) 'insufficient-funds)) (deposit (amt) (incf balance amt)) (balance () balance) (name () name) (interest () (incf balance (* interest-rate balance)))) Classes (defmacro define-class (class inst-vars class-vars &body methods) class definition." `(let,class-vars (mapcar #'ensure-generic-fn ',(mapcar #'first methods)) (defun,class,inst-vars #'(lambda (message) (case #'make-clause methods)))))) (defun make-clause (clause) "Translate a message from define-class into a case clause." `(,(first clause) #'(lambda,(second clause),@(rest (rest clause)))))

8 Classes II (defun ensure-generic-fn (message) defines a generic function." (unless (or (generic-fn-p message) (eq message otherwise)) (let ((fn #'(lambda (object &rest args) (apply (get-method object message) args)))) (setf (symbol-function message) fn) (setf (get message 'generic-fn) fn)))) (defun generic-fn-p (fn-name) is fn-name a function?" (and (fboundp fn-name) (eq (get fn-name 'generic-fn) (symbol-function fn-name)))) Classes II (define-class account (name &optional (balance 0)) ((interest-rate.06)) (withdraw (amt) (if (<= amt balance (decf balance amt) 'insufficient-funds)) (deposit (amt) (incf balance amt)) (balance () balance) (name () name) (interest () (incf balance (* interest-rate balance))))

9 Classes III o Macro expansion: (LET ((INTEREST-RATE 0.06)) (MAPCAR #'ENSURE-GENERIC-FN '(WITHDRAW DEPOSIT BALANCE NAME INTEREST)) (DEFUN ACCOUNT (NAME &OPTIONAL (BALANCE 0.0)) #'(LAMBDA (MESSAGE) (CASE MESSAGE (WITHDRAW #'(LAMBDA (AMT) (IF (<= AMT BALANCE) (DECF BALANCE AMT) 'INSUFFICIENT-FUNDS))) (DEPOSIT #'(LAMBDA (AMT) (INCF BALANCE AMT))) (BALANCE #'(LAMBDA NIL BALANCE)) (NAME #'(LAMBDA NIL NAME)) (INTEREST #'(LAMBDA NIL (INCF BALANCE (* INTEREST-RATE BALANCE)))))))) Classes III o Using the new objects: o > (setf acct2 (account "A. User" )) #<CLOSURE > o > (deposit acct ) -> o > (interest acct2) -> o > (balance acct2) -> !!! o > (balance acct) -> Previous object

10 Delegation I o Account with password: (define-class password-account (password acct) () (change-password (pass new-pass) (if (equal pass password) (setf password new-pass) 'wrong-password)) (otherwise (pass &rest args) (if (equal pass password) (apply message acct args) 'wrong-password))) Delegation I o Details of the define-class macro: message and otherwise. > (setf acct3 (password-account "secret" acct2)) #<CLOSURE > > (balance acct3 "secret") -> > (withdraw acct3 "guess" ) -> WRONG-PASSWORD > (withdraw acct3 "secret" ) ->

11 Delegation II o The same technique for limited accounts: (define-class limited-account (limit acct) () (withdraw (amt) (if (> amt limit) 'over-limit (withdraw acct amt))) (otherwise (&rest args) (apply message acct args))) Delegation II o > (setf acct4 (password-account "pass" (limited-account (account "A. Thrifty Spender" )))) #<CLOSURE > o > (withdraw acct4 "pass" ) OVER-LIMIT o > (withdraw acct4 "pass" 20.00) o > (withdraw acct4 "guess" 20.00) WRONG-PASSWORD

12 o o Delegation III Each class implements a different withdraw method. Sending the message withdraw to the object acct4 : 1. password-account method validates the password. 2. If correct, sends the message withdraw to the limited-account object. 3. If under the limit, sends the message withdraw to the account object. Notice the differences with the procedural version (defun withdraw (acct amt &optional pass) (cond ((and (typep acct 'password-account) (not (equal pass (account-password acct)))) 'wrong-password) ((and (typep acct 'limited-account) (> amt (account-limit account))) 'over-limit) ((> amt balance) 'insufficient-funds) (t (decf balance amt)))) Inheritance I o Classes are hierarchically organized. It is necessary to make explicit this hierarchy. o Lisp structures implement inheritance: (defstruct (limited-account (:include account)) limit) o The same for classes: (define-class limited-account account (limit) () (withdraw (amt) (if (>amt limit) 'over-limit (call-next-method)))

13 Inheritance II o Multiple inheritance : (define-class limited-account-with-password (password-account limited-account)) o Union of the functionalities belonging to the two classes. o No new variable or methods. LISP world Smalltalk LAMBDA Flavors History Algol60 multiple inheritance method combination Simula Classes single inheritance Dahl 1966 Nygaard Kay 1969 Goldberg Ingalls Steele 1976 Cannon Weinreb 1979 New Flavors generic functions Symbolics 1981 CommonLoops Oaklisp CLOS multimethods Common Lisp Object System C++ Eiffel JAVA Xerox 1982 AT&T Bell labs 1986 Meyer 1988 Lang 1988 Perlmutter Steele 1991

14 CLOS: defclass Our System define-class methods in class class-name call-next-method ensure-generic-fn CLOS defclass defmethod make-instance call-next-method ensure-generic-function o Definition of: o Classes: defclass o Methods: delmethod o Instances: make-instance. o Syntax of class definition: (defclass class-name (superclass...) (slot-specifier...) optional-class-option...) defclass (slots and implicit methods) (defclass account () ((name :initarg :name :reader name) (balance :initarg :balance :initform 0.00 :accessor balance) (interest-rate :allocation :class :initform.06 :reader interest-rate))) > (setf a1 (make-instance 'account :balance :name "Fred")) #<ACCOUNT > > (name a1) "Fred" > (balance a1) > (interest-rate a1) 0.06

15 CLOS: defmethod (defmethod method-name (parameter...) body...) (defmethod withdraw ((acct account) amt) (if (< amt (balance acct)) (decf (balance acct) amt) 'insufficient-funds)) o limited-account class is a subclass of account class. (defclass limited-account (account) ((limit :initarg :limit :reader limit))) (defmethod withdraw ((acct limited-account) amt) (if (> amt (limit acct)) 'over-limit (call-next-method))) Inheritance example > (setf a2 (make-instance 'limited-account :name "A. Thrifty Spender" :balance :limit )) #<LIMITED-ACCOUNT > Values to slots inherited from the account class. > (name a2) "A. Thrifty Spender" Name method is inherited. > (withdraw a ) OVER-LIMIT > (withdraw a ) Using call-next-method. Multiple: left to right

16 Examples (defclass audited-account (account) ((audit-trail :initform nil :accessor audit-trail))) (defmethod withdraw :before ((acct audited-account) amt) (push (print `(withdrawing,amt)) (audit-trail acct))) RETURN (defmethod withdraw :after ((acct audited-account) amt) (push (print `(withdrawal (,amt) done)) (audit-trail acct))) o o Order: 1. All the methods :before, from more specific to more general 2. Primary methods: the most specific (call-next-method) 3. All the methods :after, from more general to more specific Auxiliary method :around o The most specific (call-next-method) Examples > (setf a3 (make-instance 'audited-account :balance )) #<AUDITED-ACCOUNT > > (withdraw a ) (WITHDRAWING 100.0) (WITHDRAWAL (100.0) DONE) > (audit-trail a3) ((WITHDRAWAL (100.0) DONE) (WITHDRAWING 100.0)) > (setf (audit-trail a3) nil) NIL o CLOS problem: Encapsulation of methods. Methods are not defined into the classes.

17 OOP Example: Search tools o OOP is useful to implement two important models of representation: 1. Isomorphism between real objects and computational objects. 2. Program combination as a building tool for programming. o The second model is useful for searching. o Classification of search problems: o Domain: planning, games, etc. o Topology: tree, graph, etc. o Search strategy: depth-first, breadth-first, etc. o Modularity Search tools o A problem contains a space of states. (defclass problem () ((states :initarg :states :accessor problem-states)))

18 Search I o The definition of the search method of the problem class uses generic functions. (defmethod searcher ((prob problem)) Finding a solution state" (cond ((no-states-p prob) fail) ((goal-p prob) (current-state prob)) (t (let ((current (pop-state prob))) (setf (problem-states prob) (problem-combiner prob (problem-successors prob current) (problem-states prob)))) old (searcher prob)))) new Search I (defmethod current-state ((prob problem)) "The current state is the first of the possible states." (first (problem-states prob))) (defmethod pop-state ((prob problem)) "Remove and return the current state." (pop (problem-states prob)))

19 Search II (defmethod no-states-p ((prob problem)) "Are there any more unexplored states?" (null (problem-states prob))) (defmethod searcher :before ((prob problem)) (format t "~&;; Search: ~a" (problem-states prob))) (defmethod searcher ((prob problem)) Finding a solution state" (cond ((no-states-p prob) fail) ((goal-p prob) (current-state prob)) (t (let ((current (pop-state prob))) (setf (problem-states prob) (problem-combiner prob (problem-successors prob current) (problem-states prob)))) (searcher prob)))) Search II Problem subclass: problems with a goal. (defclass eql-problem (problem) ((goal :initarg :goal :reader problem-goal))) (defmethod goal-p ((prob eql-problem)) (eql (current-state prob) (problem-goal prob)) (defmethod searcher ((prob problem)) Finding a solution state" (cond ((no-states-p prob) fail) ((goal-p prob) (current-state prob)) (t (let ((current (pop-state prob))) (setf (problem-states prob) (problem-combiner prob (problem-successors prob current) (problem-states prob)))) (searcher prob))))

20 Strategies o Two subclasses of problems with search strategies: (defclass dfs-problem (problem)() (:documentation "Depth-first search problem.")) (defclass bfs-problem (problem)() (:documentation "Breadth-first search problem.")) (defmethod problem-combiner ((prob dfs-problem) new old) "Depth-first search looks at new states first." (append new old)) (defmethod problem-combiner ((prob bfs-problem) new old) "Breadth-first search looks at old states first." (append old new)) Domain and combination o Subclass of problem representing the topology type and the domain knowledge by means of successors computing. (defclass binary-tree-problem (problem) ()) (defmethod problem-successors ((prob binary-tree-problem) state) (let ((n (* 2 state))) (list n (+ n 1)))) o Finally we show the power of multiple inheritance by combining: topology, strategy and the problem type (goal-oriented). (defclass binary-tree-eql-bfs-problem (binary-tree-problem eql-problem bfs-problem) ())

21 Run the example > (setf p1 (make-instance 'binary-tree-eql-bfs-problem :states '(1) :goal 12)) #<BINARY-TREE-EQL-BFS-PROBLEM > > (searcher p1) ;; Search: (1) ;; Search: (2 3) ;; Search: (3 4 5) ;; Search: ( ) ;; Search: ( ) ;; Search: ( ) ;; Search: ( ) ;; Search: ( ) ;; Search: ( ) ;; Search: ( ) ;; Search: ( ) ;; Search: ( ) 12 First summary Problem states, Current state, pop-state no-states-p, searcher bfs-problem dfs-problem problem-combiner problem-combiner eql-problem Goal goal-p binary-tree-problem problem-successors binary-tree-eql-bfs-problem

22 Other search strategies o Advantages of modularity (defclass best-problem (problem) () (:documentation "A Best-first search problem.")) (defmethod problem-combiner ((prob best-problem) new old) "Best-first search sorts new and old according to cost-fn." (sort (append new old) #'< :key #'(lambda (state) (cost-fn prob state)))) (defmethod cost-fn ((prob eql-problem) state) (abs (- state (problem-goal prob)))) ( (defclass beam-problem (problem) ((beam-width :initarg :beam-width :initform nil :reader problem-beam-width))) (defmethod problem-combiner :around ((prob beam-problem) new old) (subseq (call-next-method) 0 (problem-beam-width prob))) New combination (defclass binary-tree-eql-best-beam-problem (binary-tree-problem eql-problem best-problem beam-problem) ()) > (setf p3 (make-instance 'binary-tree-eql-best-beam-problem :states '(1) :goal 12 :beam-width 3)) #<BINARY-TREE-EQL-BEST-BEAM-PROBLEM > > (searcher p3) ;; Search: (1) ;; Search: (3 2) ;; Search: (7 6 2) ;; Search: ( ) ;; Search: ( ) ;; Search: ( ) ;; Search: ( ) 12

23 New schema Problem states, Current state, pop-state no-states-p, searcher best-problem beam-problem problem-combiner problem-combiner eql-problem Goal goal-p cost-fn binary-tree-problem problem-successors binary-tree-eql-best-beam-problem