Encapsulation. Imperative programming abstraction via subprograms Modular programming data abstraction. TUT Pervasive Computing 1

Transcription

1 Encapsulation Imperative programming abstraction via subprograms Modular programming data abstraction Encapsulation grouping of subprograms and the data they manipulate Information hiding abstract data types implementation of the type is hidden from the user variables of the type can be declared variables of the type can be used via the operations defined for the type Mechanisms modules, packages, classes nested subprograms, file system TUT Pervasive Computing 1

2 Module vs. class program modularization (division into parts) separate compilation Module static structure interface and implementation scope Class no code is generated from a module dynamic module it is possible to create run time instances corresponds to a type TUT Pervasive Computing 2

3 Module definition and use (Modula-2) DEFINITION MODULE Stack; PROCEDURE Push ( X: CARDINAL ); PROCEDURE Pop ( ): CARDINAL; VAR Empty, Error: BOOLEAN; END Stack; IMPORT Stack; Stack.Push ( 3 ); FROM Stack IMPORT Push; Push ( 3 ); TUT Pervasive Computing 3

4 Module implementation (Modula-2) IMPLEMENTATION MODULE Stack; CONST N = 100; TYPE Index = [ 0..N ]; VAR Top: Index; S: ARRAY Index OF CARDINAL; PROCEDURE Push ( X: CARDINAL ); PROCEDURE Pop ( ): CARDINAL; BEGIN Error := FALSE; Empty := TRUE; Top := 0; END Stack; BEGIN (* Push *) IF Top = N THEN Error := TRUE; ELSE Top := Top + 1; S [ Top ] := X; Empty := FALSE; END; END Push; BEGIN (* Pop *) IF Top = 0 THEN Error := TRUE; ELSE Top := Top 1; IF Top = 0 THEN Empty := TRUE END; RETURN S [ Top + 1 ]; END; END Pop; TUT Pervasive Computing 4

5 Module use (Modula-2) MODULE StackUser; IMPORT Stack; C: CARDINAL; BEGIN Stack.Push ( 5 ); C := Stack.Pop ( ); END StackUser; Deficiencies of the example: user can change the values of variables Error and Empty it is not possible to create several stacks TUT Pervasive Computing 5

6 Improving the example Using module as a manager for a type (e.g. stack) This requires: an operation to create (initialize) a stack instance an operation to delete a stack instance for each operation an additional parameter to tell which stack instance the operation is applied to Stack type is defined as an opaque type restrictions to variables of this type they can be passed as parameters to module operations they can be assigned and their equality can be tested corresponds to an abstract data type TUT Pervasive Computing 6

7 Definition of an abstract data type Modula-2: DEFINITION MODULE StackManager; TYPE Stack; PROCEDURE Push ( S: Stack, X: CARDINAL ); PROCEDURE Pop ( S: Stack ): CARDINAL; PROCEDURE Empty ( S: Stack ): BOOLEAN; PROCEDURE Initialize ( VAR S: Stack ); END StackManager; Restrictions for an opaque type (in Modula-2): it must be a pointer size is always the same: recompilation is minimized TUT Pervasive Computing 7

8 Modula-2: Implementation of an abstract data type IMPLEMENTATION MODULE StackManager; FROM Storage IMPORT ALLOCATE; CONST N = 100; TYPE Index = [ 1..N ]; StackRec = RECORD Top: Index; StackArr: ARRAY Index OF CARDINAL END; Stack = POINTER TO StackRec; PROCEDURE Pop ( S: Stack ): CARDINAL; BEGIN IF S^.Top > 0 THEN S^.Top := S^.Top 1; RETURN S^.StackArr [ S^.Top + 1 ] END END Pop; PROCEDURE Initialize ( VAR S: Stack ); BEGIN NEW ( S ); S^.Top := 0 END Initialize; END StackManager; TUT Pervasive Computing 8

9 Modula-2: Use of an abstract data type VAR S1, S2: StackManager.Stack; I: CARDINAL; StackManager.Initialize ( S1 ); StackManager.Initialize ( S2 ); StackManager.Push ( S1, 2 ); StackManager.Push ( S2, 3 ); IF NOT StackManager.Empty ( S1 ) THEN I := StackManager.Pop ( S1 ); END; TUT Pervasive Computing 9

10 Shortcomings of modules It is possible to declare several types inside the same module Modules do not totally fulfil the encapsulation intent (i.e. tight cohesion between the type and its operations) An operation in a module is an external object, to which a certain instance (e.g. stack) is passed as a parameter Do not support inheritance (and reuse) TUT Pervasive Computing

11 Classes Put together those objects that have the same behavior Support abstract data types better than modules modules can be used by importing them classes can be used in variable declarations like types Class hierarchy (inheritance) behavior of the superclass instances is copied to be part of the behavior the subclass instances multiple inheritance vs. single inheritance Meta class a class described as a class TUT Pervasive Computing 11

12 package Complex is procedure Initialize ( r, i: Float ); function IsZero return Boolean; private re: Float; im: Float; end Complex; package ComplexManager is with Complex; Complex.Initialize ( 1.0, 2.0 ); if Complex.IsZero then class Complex { public: Complex ( ); Complex ( float, float ); virtual ~Complex ( ); int iszero ( ); private: c1: Complex; float re; }; float im; C++ Ada c2: Complex ( 1.0, 2.0 ); if ( c1.iszero ( ) ) Comparison of modules and classes type Complex is private; procedure Initialize ( c: in out Complex; r: in Float; i: in Float ); function IsZero ( c: Complex ) return Boolean; private type Complex is record re: Float; im: Float; end record; end ComplexManager; with ComplexManager; use ComplexManager; c1, c2 : Complex; Initialize ( c1, 0.0, 0.0 ); Initialize ( c2, 1.0, 2.0 ); if IsZero ( c1 ) then TUT Pervasive Computing 12

13 Design issues for object-oriented languages Exclusivity of objects consistency vs. inefficiency Are subclasses subtypes? consistency between subclasses and superclasses Implementation and interface inheritance dependency vs. inefficiency Single and multiple inheritance Dynamic/static binding, dynamic/static typing Allocation and deallocation of objects Vector v = new Vector ( ); v.addelement ( new Integer ( 10 ) ); C++: Java: int second ( ) { int temp = top ( ); pop ( ); int temp_result = top ( ); push ( temp ); return temp_result; } TUT Pervasive Computing 13

14 Inheritance choices (C++) Implementation inheritance implementation defined as protected in the superclass Interface inheritance implementation defined as private in the superclass Subclass is not a subtype private features of the superclass are not visible in subclasses private inheritance class BaseClass { private: int a; float x; protected: int b; float y; public: int c; float z; }; class SubClass1: public BaseClass { }; class SubClass2: private BaseClass { }; TUT Pervasive Computing 14

15 Influences of inheritance (C++) private-inheritance: natural in this case subclass is not a subtype void push ( int i ) { insert_at_head ( i ); } int pop ( ) { return remove_at_head ( i ); } stack + push ( int ) + pop ( ) linked_list + insert_at_head ( int ) + insert_at_tail ( int ) + remove_at_head ( ) queue + enqueue ( int ) + dequeue ( ) void enqueue ( int i ) { insert_at_tail ( i ); } int dequeue ( ) { return remove_at_head ( i ); } TUT Pervasive Computing 15

16 Object lifetime Creation constructors (zero, one, or several) selecting a constructor (overloading) execution order of the constructors objects as references (e.g. Java, Simula, Smalltalk) explicit creation (constructor call) objects as values (e.g. C++, Oberon, Ada95) creation can be implicit during declaration elaboration Deletion either with explicit command or automatically languages with automated garbage collection do not necessarily need destructors TUT Pervasive Computing 16

17 int a; Objects as values or as references C++: foo a; foo a ( 10 ); foo::foo ( ) foo::foo ( int ) Java: foo a; a = new foo ( ); foo a = new foo ( ); Initialization: foo a; foo c = a; Assignment: foo a, c; c = a; foo::foo ( foo& ) foo::operator= ( foo& ) TUT Pervasive Computing 17

18 Object creation (C++) Automatic object created at declaration elaboration, deleted when exiting the block Static object created when execution starts and deleted when it terminates Dynamic object created and deleted with explicit command class C1 { classc x; } Member object { classc x; } static classc x; or in main: x = new classc; delete x; classc x; created and deleted with the object whose member the member object is TUT Pervasive Computing 18

19 Object creation (in general) Stack memory allocation for objects: size must be known during compilation Inheritance: objects that look like base class objects can really be of derived class! So size depends on situation In many languages memory for objects is always allocated from the heap Same goes for member objects in a class TUT Pervasive Computing

20 Operation binding Dynamic binding = run time binding enables polymorphism that is typical for object orientation implemented via virtual operations Virtual operation operation to be called is selected on the basis of the object s current class Polymorphism in object-oriented languages superclass instance can be replaced with a subclass instance in general a named object can be replaced with another named object genericity, templates (parametric polymorphism) overloading (ad hoc polymorphism) TUT Pervasive Computing 20

21 Static and dynamic binding class person { } class student: public person { } class professor: public person { } contact-operation is defined in all three classes student s; professor p; person *x = &s; person *y = &p; s.contact ( ); // student::contact ( ) p.contact ( ); // professor::contact ( ) x->contact ( ); //?? y->contact ( ); //?? Static binding redefine method is selected on the basis of the variable type Dynamic binding override method is selected on the basis of the object s class TUT Pervasive Computing 21

22 Static and dynamic binding in programming languages Dynamic binding for all operations Smalltalk, Modula-3 Dynamic binding as default Java, added with final definition Eiffel, added with frozen definition Static binding as default C++, added with virtual definition Simula, added with virtual definition Ada95, class wide types used as formal parameters Operations cannot be overridden in subclasses TUT Pervasive Computing 22

23 Implementation of object orientation Features in memory class resembles a record (especially in C++) CIR (class instance record) information static structure about an object each feature can be found by evaluating the offset of the feature subclass adds its own features after the CIR of the superclass Dynamically bound operations references to these operations can be found from CIR list of operations that can be bound dynamically virtual method table (VMT, vtable) information about a class TUT Pervasive Computing 23

24 Implementation of object orientation Dynamically bound operations in dynamically typed object oriented languages each class has a method parser function method parser receives method name and parameters and decides what code to call if parser finds no suitable method, it gives a run-time error if subclass parser finds no suitable method, it calls base class parser(s) before giving an error slower than static methods, but more flexible in some languages, programmer may write custom method parsers for a class TUT Pervasive Computing 24

25 Implementing classes and dynamically bound operations class Foo { int x; double y; char z; public: virtual void k ( ); virtual int l ( ); virtual void m ( ); virtual double n ( ); } f; CIR of f x y z VMT of Foo k l m n code of k code of l code of m code of n TUT Pervasive Computing 25

26 Implementing single inheritance class Bar: public Foo { int w; public: void m ( ); // override virtual double s ( ); virtual char *t ( ); } b; CIR of b x y z w VMT of Bar k code of Foo::k l code of Foo::l m code of Bar::m n code of Foo::n s code of Bar::s t code of Bar::t TUT Pervasive Computing 26

27 Assignment compatibility C++ class foo { } class bar: public foo { } foo f; bar b; foo *fr; bar *br; fr = &b; // ok: the first parts of // data store and VMT // of b are assigned br = &f; // error: f is lacking the // end parts br = dynamic_cast<bar*> ( fr ); Eiffel Backward assignment Reverse assignment class foo class bar inherit foo f: foo; b: bar; f := b; -- ok b?= f; -- assignment -- succeeds, if f refers -- to b object, -- otherwise nil is -- assigned TUT Pervasive Computing 27

28 Choices for multiple inheritance Non-repeated multiple inheritance inherited superclasses are separate in the class hierarchy Repeated multiple inheritance replicated multiple inheritance shared multiple inheritance diamond inheritance B A C B A B D D C A C D TUT Pervasive Computing 28

29 Implementing multiple inheritance Name conflict inherited classes may have features of the same name how to refer to the features of all the superclasses C++: operator :: A Eiffel: renaming B Shared inheritance (diamond inheritance) by which way does D inherit features of A any feature inherited from A can be redefined in B or C D C TUT Pervasive Computing 29

30 B C Non-repeated multiple inheritance D D view, B view C view CIR of D obj. B fields C fields D (only) fields VMT of D (D/B part) B operations D (only) operations VMT of D (C part) C operations TUT Pervasive Computing 30

31 Replicated multiple inheritance A A D view, B view, B::A view C view, C::A view CIR of D obj. B::A fields B (only) fields C::A fields C (only) fields D (only) fields VMT of D (D/B part) B::A operations B (only) operations D (only) operations VMT of D (C part) C::A operations C (only) operations B D A *a; B *b; D *d; a = d; b = d; a = b; C OK. /. TUT Pervasive Computing 31

32 Shared multiple inheritance A D view, B view C view A view CIR of D obj. B (only) fields C (only) fields D (only) fields A fields VMT of D (D/B part) B operations D operations VMT of D (C part) C operations VMT of D (A part) A operations B C D TUT Pervasive Computing 32