Design issues for objectoriented. languages. Objects-only "pure" language vs mixed. Are subclasses subtypes of the superclass?

Transcription

1 Encapsulation Encapsulation grouping of subprograms and the data they manipulate Information hiding abstract data types type definition 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,

2 lasses Modules encapsulate data types and operations that operate on them, data and operations are still separate modules can be used by importing them lasses support abstract data types better than modules classes are types, objects variables, operations methods of objects/classes lass hierarchy (inheritance) behavior of the superclass is copied to be part of the behavior the subclass multiple inheritance vs. single inheritance Meta class a class itself is described as an object of a metaclass 189

3 Design issues for objectoriented languages Objects-only "pure" language vs mixed consistency (only objects) vs. efficiency (primitive types) Are subclasses subtypes of the superclass? consistency between subclasses and superclasses Dynamic/static binding of methods Are pure interfaces (no implementation) provides as a separate concept Single vs multiple inheritance Dynamic/static typing Allocation and deallocation of objects 190

4 Object creation 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 (often implies reference semantics) Same goes for data members in a class ++ allows stack allocation & embedded data members, this causes problems (slicing) and restricts use of inheritance 191

5 Method binding Dynamic binding = run time binding enables polymorphism (typical for object orientation) implemented via virtual operations Virtual operation operation to be called is selected on the basis of the object s real class, not the class of the reference used to access the object Polymorphism: a single interface to entities of different types in object-oriented languages, inheritance: all subclass objects can be used via superclass interface genericity, templates (parametric polymorphism) overloading (ad hoc polymorphism) 192

6 Static and dynamic binding in programming languages Static binding: Operations can't/shouldn't be overridden in subclasses Dynamic binding for all operations Python, Smalltalk, Modula-3 Dynamic binding as default Java, static with final keyword Eiffel, static with frozen keyword Static binding as default ++, dynamic with virtual and override (++11) specifiers ++11, overriding prohibited with final specifier 193

7 Implementing classes and objects (static typing) information about an object information about a class Features in memory class resembles a record (especially in ++) IR (class instance record) static structure each feature can be found by evaluating the offset of the feature subclass adds its own features after the IR of the superclass Dynamically bound operations references to these operations can be found from IR list of operations that can be bound dynamically virtual method table (VMT, vtable) 194

8 Implementing classes and objects (dynamic typing) 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 runtime 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 195

9 Object and method table class Foo { int x; double y; char z; public: virtual void k (... ); virtual int l (... ); virtual void m (... ); virtual double n (... );... }; Foo f; IR of f x y z VMT of Foo k code of Foo:k l code of Foo:l m code of Foo:m n code of Foo:n 196

10 Implementing single inheritance class ar: public Foo { int w; public: virtual void m (... ); // = override virtual double s (... ); virtual char *t (... );... }; ar b; IR of f x y z IR of b x y z VMT of Foo k l m n VMT of ar k l m n s t code of Foo:k code of Foo:l code of Foo:m code of Foo:n code of ar::m code of ar::s code of ar::t w 197

11 hoices 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 A A D D A D 198

12 Implementation issues for multiple inheritance Name conflict inherited classes have features with the same name how to refer to the features of the different superclasses ++: operator :: Eiffel: renaming Shared inheritance (diamond inheritance) how does D access features of A? any feature inherited from A can be redefined in or (or both!) A D 199

13 Non-repeated multiple inheritance D view, view view IR of D obj. D (only) D VMT of D (D/ part) operations D (only) operations VMT of D ( part) operations 200

14 A A Replicated multiple inheritance D view, view, ::A view IR of D obj. ::A (only) VMT of D (D/ part) ::A operations (only) operations D (only) operations D view, ::A view ::A VMT of D ( part) ::A operations (only) (only) operations D (only) 201

15 A Shared multiple inheritance D view, view IR of D obj. (only) VMT of D (D/ part) operations D operationn D view VMT of D ( part) operations (only) A view D (only) A VMT of D (A part) A operations 202