Lecture 16: Object Programming Languages

Transcription

1 Lecture 16: Object Programming Languages Introduction Corresponds to EOPL 5.1 and 5.2 Goal: to introduce Object Oriented Programming Language (OOPL) concepts using the EOPL extensible language framework Outline Introduction of basic OOPL concepts Define an OOPL extension to the PL of Chapter 3 Give 4 implementations (each more sophisticated) School of Computing Simon Fraser University Copyright Bill Havens 1

2 OOPL History History Programming increases complexity along with the problem domain Traditional procedural/functional PLs provide little assistance with modelling the problem Basic Idea: Programs should be models of the problem to be solved Entities in the model should be isomorphic to corresponding entities in the problem Insight came from Kristen Nygaard in Norway (1957!!!) Building complex simulations of a nuclear power plant First OOPL called SIMULA-67 (Dahl & Nygaard) See Extension of Algol-60 Introduced objects, classes, inheritance, virtual methods, garbage collection Progenitor of future OOPLs: Smalltalk, Flavors, CLOS, C++, Java Copyright Bill Havens 2

3 Basic OOPL concepts Concepts Classes Objects Message Passing Methods Persistent state Encapsulation Inheritance Overriding Polymorphism Copyright Bill Havens 3

4 Classes et cetera Classes Isomorphism to ontology of problem domain What are the salient entities of the problem? What are their state variables? What is the behavior of the class in the problem model? What methods can be defined to implement the desired behavior? Objects Used to populate the problem model Notion of an instance of the class What parameters differentiate members of the class? How to they interact in the problem? Copyright Bill Havens 4

5 Message Passing How can object interaction be modelled as message passing among objects? Art of OOPL! Messages exchanged from a sender object to a receiver object Concept of polite message passing (ACTOR formalism of Hewitt 1973) See Methods Mapping of message passing notion to remote procedure invocation (RPI) Message type = proc name; message content = proc app arguments Requires a send operator to implement RPI Blocking send with possible return value Persistent State OO programming assumes a vonneumann model of computation Program state stored in persistent state variables (object variables) Messages either interrogate or mutate the state of receiver object variables Copyright Bill Havens 5

6 Encapsulation Objects are opaque! Internal state and its representation are hidden from other objects Only available via message passing Notion of a public interface for accessing an object Encapsulation perhaps the most powerful concept in modern OOPLs. Makes developing/extending/maintaining large software systems possible Internal state and methods of an object can be changed without affecting the public interface (behavior) of the object Class Inheritance Notion of subclass and superclass Behavior of a class inherited by all of its subclasses recursively Both persistent state and methods Single and multiple superclass inheritance possible 1. Multiple inheritance: C++ 2. Single inheritance: Java Key to maintaining consistent object behaviour Copyright Bill Havens 6

7 Method Overriding Subclasses can specialize the public behaviour of their ancestor classes Adding semantics to classes means subclassing with method overriding Polymorphism A subclass object can be used wherever any of its ancestors can be used Subclass covers the public interface of its ancestors Overriding makes polymorphism possible Polymorphism is a powerful OOPL tool Copyright Bill Havens 7

8 Static vs. Dynamic Method Dispatch Overview Static method dispatch knows the message receiver method at compile time Dynamic method dispatch looks up receiver method at runtime Polymorphism requires dynamic method dispatching Called virtual methods in C++ Standard in Java What is this? Copyright Bill Havens 8

9 Polymorphic Example class Shape extends Object { abstract void draw(); // canʼt draw an arbitrary shape... } class Rectangle extends Shape { void draw () { --- draw this rectangle --- } } class Circle extends Shape { void draw () { --- draw this circle --- } } static void main() { Shape x = new Rectangle(); Shape y = new Circle; x.draw(); y.draw } What gets drawn??? 1. for static method dispatching 2. for dynamic method dispatching Copyright Bill Havens 9

10 OOPL specifications Specs EOPL 5.3 Single inheritance Dynamic method dispatching True polymorphism Special self variable supported Super class methods supported (static dispatching) Syntax A program is a sequence of class declarations followed by a single expression <program> --> {<class-decl>}* <expression> A class declaration is a name, superclass name, field declarations, and method declarations <class-decl> --> class <id> extends <id> {field <id>}* {<method-decl>}* Copyright Bill Havens 10

11 Syntax continued A method declaration looks like a procedure <method-decl> --> method <id> ({<id>}* <expression> We also add 3 new types of expressions to our interpreter language The new operator makes a new instance from a class <expression> --> new <id> ({<expression>}*) The send operator performs RPI (message passing) <expression> --> send <expression> <id> ({<expression>}*) The super operator sends a message to the static superclass of this object <expression> --> super <id> ({<expression>}*) We need to extend the PL of Chapter3 to include this new OOPL functionality Expressed / Denoted Values Extended our language significantly for Expressed Values ExpressedValue = Numer + ProcVal + Object + List(ExpressedValue) DenotedValue = Ref(ExpressedValue) Note that all variables are reference vars Classes are not expressable (like Java and C++) Copyright Bill Havens 11

12 Our OOPL Example class c1 extends object field i field j method initialize(x) begin set i = x set j = -(0, x) end method countup(d) begin set i = +(i, d) set j = -(j, d) end method getstate() list(i, j) let t1 = 0 t2 = 0 o1 = new c1(3) in begin set t1 = send o1 getstate(); send o1 countup(2); set t2 = send o1 getstate(); list(t1, t2) end What does this program compute? What functionality do we need to implement? School of Computing Simon Fraser University Copyright Bill Havens 12

13 1st OOPL Implementation Overview Define an implementation interface that each version of the OOPL must implement Interface 1. elaborate-class-decls : compiles a runtime representation of the class declarations useable by the augmented interpreter 2. find-method-and-apply : performs message passing; looks up named method in the class hierarchy and applies it to the supplied arguments 3. object->class-name : given an object, returns the name of its class 4. new-object : the constructor which makes a new object from a class name and specified initialization arguments. Now we can extend the interpreter for eval-program and eval-expression Next we will give a first implementation of the 4 interface methods above Copyright Bill Havens 13

14 Extended Interpreter Eval Program (define eval-program (lambda (pgm) (cases program pgm (a-program (c-decls exp) (elaborate-class-decls! c-decls) (eval-expression exp (empty-env)))))) Only change is to compile class declarations Simplest possible implementation Just use the abstract datatype representation of the classes themselves! (define the-class-env '()) (define elaborate-class-decls! (lambda (c-decls) (set! the-class-env c-decls))) Copyright Bill Havens 14

15 Eval Expression Extended Interpreter (contd) (define eval-expression (lambda (exp env) (cases expression exp... % as before (new-object-exp (class-name rands) (let ((args (eval-rands rands env)) (obj (new-object class-name))) (find-method-and-apply 'initialize class-name obj args) obj)) (method-app-exp (obj-exp method-name rands) (let ((args (eval-rands rands env)) (obj (eval-expression obj-exp env))) (find-method-and-apply method-name (object->class-name obj) obj args))) (super-call-exp (method-name rands) (let ((args (eval-rands rands env)) (obj (apply-env env 'self))) (find-method-and-apply method-name (apply-env env '%super) obj args))) ))) Lets consider each new clause in turn... School of Computing Simon Fraser University Copyright Bill Havens 15

16 To send a message: Message Send (v1) 1. evaluate the receiver object expression 2. evaluate the message operands 3. lookup the correct method in the class hierarchy 4. Call the method with the evaluated arguments 5. Return the result as the value of the message send Code (repeated) (method-app-exp (obj-exp method-name rands) (let ((args (eval-rands rands env)) (obj (eval-expression obj-exp env))) (find-method-and-apply method-name (object->class-name obj) obj args))) Only need to implement function find-method-and-apply School of Computing Simon Fraser University Copyright Bill Havens 16

17 function find-method-and-apply (define find-method-and-apply (lambda (m-name host-name self args) (if (eqv? host-name 'object) (eopl:error 'find-method-and-apply "No method for name ~s" m-name) (let ((m-decl (lookup-method-decl m-name (class-name->method-decls host-name)))) (if (method-decl? m-decl) (apply-method m-decl host-name self args) (find-method-and-apply m-name (class-name->super-name host-name) self args)))))) function lookup-method-decl looks up the correct method implementation in the class declaration hierarchy for the host (declared) class of the object recursively. Note failure on class object Method evaluation analogous to closure evaluation Need to define method called apply-method... School of Computing Simon Fraser University Copyright Bill Havens 17

18 function apply-method Evaluate the body of the method in the environment of the objects declared and inherited variables (fields) These variables are containted in the list (chain) representing the object. Includes 2 special variables 1. Variable self which references the receiver object 2. Variable %super which references the superclass of the receiver Need a way of kowing whether to start at the class (host) of receiver or its superclass or higher. function view-object-as is used to search this chain (define view-object-as (lambda (parts class-name) (if (eqv? (part->class-name (car parts)) class-name) parts (view-object-as (cdr parts) class-name)))) Copyright Bill Havens 18

19 Building the new environment Given the right view of the inheritance hierarchy we can build a NEW environment for the message send (define build-field-env (lambda (parts) (if (null? parts) (empty-env) (extend-env-refs (part->field-ids (car parts)) (part->fields (car parts)) (build-field-env (cdr parts)))))) Now apply-method does the usual evaluation of the method body in the new environment (define apply-method (lambda (m-decl host-name self args) (let ((ids (method-decl->ids m-decl)) (body (method-decl->body m-decl)) (super-name (class-name->super-name host-name))) (eval-expression body (extend-env (cons '%super (cons 'self ids)) (cons super-name (cons self args)) (build-field-env (view-object-as self host-name))))))) School of Computing Simon Fraser University Copyright Bill Havens 19

20 To create a new object New Operator (v1) 1. evaluate the class-name expression 2. evaluate the initialization operands 3. find the correct initialize method for the class 4. apply the method to the operands 5. return the new object Code (repeated) (new-object-exp (class-name rands) (let ((args (eval-rands rands env)) (obj (new-object class-name))) (find-method-and-apply 'initialize class-name obj args) obj)) Need only function new-object School of Computing Simon Fraser University Copyright Bill Havens 20

21 function new-object (define new-object (lambda (class-name) (if (eqv? class-name 'object) '() (let ((c-decl (lookup-class class-name))) (cons (make-first-part c-decl) (new-object (class-decl->super-name c-decl))))))) (define make-first-part (lambda (c-decl) (a-part (class-decl->class-name c-decl) (make-vector (length (class-decl->field-ids c-decl)))))) This implementation represents objects (instances) as a linked-list of parts Each part is a pair: (<class-name> <vector of fields>) Note: simple accessor functions are assumed here Copyright Bill Havens 21

22 Super message call (v1) To send a message to the super class of an object: 1. Evaluate the operands of the message 2. Get reference to this object (self) 3. Lookup %super variable in the current environment 4. find-and-apply the method in the field view (using view-object-as) of the super class Code DONE! (super-call-exp (method-name rands) (let ((args (eval-rands rands env)) (obj (apply-env env 'self))) (find-method-and-apply method-name (apply-env env '%super) obj args))) School of Computing Simon Fraser University Copyright Bill Havens 22