![Page 1: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/1.jpg)
Chair of Software Engineering
Genericity & Inheritance
Bertrand MeyerETH Zurich, Switzerland
Eiffel Software, Santa Barbara
Epita, Paris, 31 March 2010
![Page 2: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/2.jpg)
2
On the menu
Two fundamental mechanisms for expressiveness and reliability:
Genericity Inheritance
with associated (just as important!) notions: Static typing Polymorphism Dynamic binding
![Page 3: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/3.jpg)
3
Extending the basic notion of class
LIST_OF_CARS
SET_OF_CARS
LINKED_LIST_OF_CARS
LIST_OF_CITIES
LIST_OF_PERSONS
Abstraction
Specialization
Type parameterization Type parameterization
Genericity
Inheritance
![Page 4: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/4.jpg)
4
Extending the basic notion of class
LIST_OF_CARS
SET_OF_CARS
LINKED_LIST_OF_CARS
LIST_OF_CITIES
LIST_OF_PERSONS
LINKED_LIST_OF_CITIES
SET_OF_PERSONS
Genericity
Inheritance
![Page 5: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/5.jpg)
5
Genericity
Unconstrained
LIST [G]e.g. LIST [INTEGER], LIST [PERSON]
Constrained
HASH_TABLE [G ―> HASHABLE]
VECTOR [G ―> NUMERIC ]
![Page 6: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/6.jpg)
6
Genericity: ensuring type safety
How can we define consistent “container” data structures, e.g. list of accounts, list of points?
Without genericity, something like this: c : CITY ; p : PERSONcities : LIST ... people : LIST ... ---------------------------------------------------------people.extend ( )cities.extend ( )
c := cities.last
c.some_city_operation
What if wrong?
pc
![Page 7: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/7.jpg)
7
Possible approaches
1. Duplicate code, manually or with help of macro processor
2. Wait until run time; if types don’t match, trigger a run-time failure (Smalltalk)
3. Convert (“cast”) all values to a universal type, such as “pointer to void” in C
4. Parameterize the class, giving an explicit name G to the type of container elements. This is the Eiffel approach, also found in recent versions of Java, .NET and others.
![Page 8: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/8.jpg)
8
A generic class
class LIST [ G ] featureextend (x : G ) ...last : G ...
end
Formal generic parameter
Actual generic parameterTo use the class: obtain a generic derivation, e.g.
cities : LIST [ CITY ]
![Page 9: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/9.jpg)
9
Using generic derivations
cities : LIST [CITY ]people : LIST [PERSON]c : CITYp : PERSON...
cities.extend (c)people.extend (p)
c := cities.lastc.some_city_operation
STATIC TYPINGThe compiler will reject:
people.extend (c)
cities.extend (p)
![Page 10: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/10.jpg)
10
Static typing
Type-safe call (during execution):A feature call x.f such that the object attachedto x has a feature corresponding to f
[Generalizes to calls with arguments, x.f (a, b) ]
Static type checker:A program-processing tool (such as a compiler)that guarantees, for any program it accepts, thatany call in any execution will be type-safe
Statically typed language:A programming language for which it is possible towrite a static type checker
![Page 11: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/11.jpg)
11
Using genericity
LIST [CITY ]LIST [LIST [CITY ]]…
A type is no longer exactly the same thing as a class!
(But every type remains based on a class.)
![Page 12: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/12.jpg)
12
What is a type?
(To keep things simple let’s assume that a class has zero or one generic parameter)
A type is of one of the following two forms:
C, where C is the name of a non-generic class
D [T ], where D is the name of a generic classand T is a
type
type
![Page 13: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/13.jpg)
13
A generic class
class LIST [ G ] featureextend (x : G ) ...last : G ...
end
Formal generic parameter
Actual generic parameterTo use the class: obtain a generic derivation, e.g.
cities : LIST [ CITY ]
![Page 14: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/14.jpg)
14
Reminder: the dual nature of classes
A class is a moduleA class is a type*
As a module, a class: Groups a set of related services Enforces information hiding (not all services are
visible from the outside) Has clients (the modules that use it) and suppliers
(the modules it uses)As a type, a class:
Denotes possible run-time values (objects & references), the instances of the type
Can be used for declarations of entities(representing such values)
*Or a type template(see genericity)
![Page 15: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/15.jpg)
15
Reminder: how the two views match
The class, viewed as a module, groups a set of services(the features of the class)
which are precisely the operations applicable to instances of the class, viewed as a type.
(Example: class BUS, features stop, move, speed, passenger_count )
![Page 16: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/16.jpg)
16
Extending the basic notion of class
LIST_OF_CARS
SET_OF_CARS
LINKED_LIST_OF_CARS
LIST_OF_CITIES
LIST_OF_PERSONS
Abstraction
Specialization
Type parameterization Type parameterization
Genericity
Inheritance
![Page 17: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/17.jpg)
17
Inheritance basics
Principle:Describe a new class as extension or specialization of an existing class
(or several with multiple inheritance)
If B inherits from A :
As modules: all the services of A are available in B(possibly with a different implementation)
As types: whenever an instance of A is required, an instance of B will be acceptable
(“is-a” relationship)
![Page 18: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/18.jpg)
18
Terminology
If B inherits from A (by listing A in its inherit clause): B is an heir of A A is a parent of B
For a class A:The descendants of A are A itself and (recursively) the descendants of A ’s heirs Proper descendants exclude A itself
Reverse notions:Ancestor Proper ancestor
More precise notion of instance: Direct instances of A Instances of A : the direct instances
of A and its descendants
(Other terminology: subclass, superclass, base class)
B
A
C D
E
![Page 19: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/19.jpg)
19
Example hierarchy (from Traffic)
MOVING
VEHICLE
TAXI
EVENT_TAXI
LINE_VEHICLE
TRAM BUS
position
load
busy
take +
take *
update_coordinatesmove
update_coordinates ++
move ++
* Deferred+ Effective++ Redefined
*
*
**
![Page 20: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/20.jpg)
20
Features in the example
Featuretake (from_location,
to_location : COORDINATE)-- Bring passengers-- from from_location-- to to_location.
busy : BOOLEAN--Is taxi busy?
load (q : INTEGER)-- Load q passengers.
position : COORDINATE-- Current position on map.
From class:
EVENT_TAXI
TAXI
VEHICLE
MOVING
MOVING
VEHICLE
TAXI
EVENT_TAXI
LINE_VEHICLE
TRAM BUS
*
*
**
![Page 21: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/21.jpg)
21
Inheriting features
classEVENT_TAXI
inheritTAXI
feature[… Rest of class …]
end
deferred classTAXI
inheritVEHICLE
feature[… Rest of class …]
end
All features of TAXI are applicable to instances of EVENT_TAXI
All features of VEHICLE are applicable to instances of TAXI
deferred classVEHICLE
inheritMOVING
feature[… Rest of class …]
end
All features of MOVING are applicable to instances of VEHICLE
![Page 22: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/22.jpg)
22
Inherited features
m : MOVING; v : VEHICLE; t : TAXI; e : EVENT_TAXI
v •load (…)e •take (…)m •position -- An expressiont •busy -- An expression
e •load (…)e •take (…)e •position -- An expressione •busy -- An expression
MOVING
VEHICLE
TAXI
EVENT_TAXI
LINE_VEHICLE
TRAM BUS
*
*
**
![Page 23: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/23.jpg)
23
Definitions: kinds of feature
A “feature of a class” is one of:
An inherited feature if it is a feature of one of the parents of the class.
An immediate feature if it is declared in the class, and not inherited. In this case the class is said to introduce the feature.
![Page 24: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/24.jpg)
24
Polymorphic assignment
v : VEHICLEcab : EVENT_TAXI
(VEHICLE)
(EVENT_TAXI)
v
cab
A proper descendant type
of the original
v := cab
More interesting:if some_condition then
v := cabelse
v := tram…end
tram: TRAM
![Page 25: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/25.jpg)
25
Assignments
Assignment:target := expression
With polymorphism:The type of expression is a descendant of thetype of target
So far (no polymorphism):
expression was always of the same type as target
![Page 26: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/26.jpg)
26
Polymorphism is also for argument passing
register_trip (v : VEHICLE )do … end
Type of actual argument is proper descendant of
type of formal
A particular call:
register_trip ( cab )
![Page 27: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/27.jpg)
27
Definitions: Polymorphism
An attachment (assignment or argument passing) is polymorphic if its target variable and source expression have different types.
An entity or expression is polymorphic if it may at runtime — as a result of polymorphic attachments —become attached to objects of different types.
Polymorphism is the existence of these possibilities.
![Page 28: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/28.jpg)
28
Definitions (Static and dynamic type)
The static type of an entity is the type used in its declaration in the corresponding class text
If the value of the entity, during a particular execution, is attached to an object, the type of that object is the entity’s dynamic type at that time
![Page 29: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/29.jpg)
29
Static and dynamic type
v : VEHICLEcab : EVENT_TAXI
(VEHICLE)
(EVENT_TAXI)
v
cab
v := cab
Static type of v :VEHICLE
Dynamic type after this assignment:EVENT_TAXI
![Page 30: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/30.jpg)
30
Basic type property
Static and dynamic type
The dynamic type of an entity will alwaysconform to its static type
(Ensured by the type system)
![Page 31: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/31.jpg)
31
Static typing
Type-safe call (during execution):A feature call x.f such that the object attachedto x has a feature corresponding to f
[Generalizes to calls with arguments, x.f (a, b) ]
Static type checker:A program-processing tool (such as a compiler)that guarantees, for any program it accepts, thatany call in any execution will be type-safe
Statically typed language:A programming language for which it is possible towrite a static type checker
![Page 32: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/32.jpg)
32
Inheritance and static typing
Basic inheritance type rule
For a polymorphic attachment to be valid,the type of the source must conform
to the type of the target
Conformance: basic definition
Reference types (non-generic): U conforms to T if U is a descendant of T
An expanded type conforms only to itself
![Page 33: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/33.jpg)
33
Conformance: full definition
A reference type U conforms to a reference type T if either: They have no generic parameters, and U is
a descendant of T. They are both generic derivations with the
same number of actual generic parameters, the base class of U is a descendant of the base class of T, and every actual parameter of U (recursively) conforms to the corresponding actual parameter of T.
An expanded type conforms only to itself.
![Page 34: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/34.jpg)
34
Static typing (reminder)
Type-safe call (during execution):A feature call x.f such that the object attachedto x has a feature corresponding to f.
[Generalizes to calls with arguments, x.f (a, b) ]
Static type checker:A program-processing tool (such as a compiler)that guarantees, for any program it accepts, thatany call in any execution will be type-safe.
Statically typed language:A programming language for which it is possible towrite a static type checker.
![Page 35: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/35.jpg)
35
Another example hierarchy
FIGURE*
OPEN_ FIGURE
*CLOSED_ FIGURE
*
SEGMENT POLYLINE POLYGONELLIPSE
CIRCLE
RECTANGLETRIANGLE
SQUARE
center * display *rotate*
perimeter *
perimeter +perimeter +
perimeter ++
diagonal
......
perimeter ++
++
side2
* deferred
+ effective
++ redefined
perimeter ++
side1
![Page 36: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/36.jpg)
36
Redefinition 1: polygons
class POLYGON inheritCLOSED_FIGURE
createmake
featurevertex : ARRAY [POINT]vertex_count : INTEGERperimeter : REAL
-- Perimeter length.do
across vertex as v loop
Result := Result + v [i ] . distance (v [i + 1])end
endinvariant
vertex_count >= 3vertex_count = vertex.count
end
vertex [i ]
vertex [i + 1]
![Page 37: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/37.jpg)
37
Redefinition 2: rectangles
class RECTANGLE inheritPOLYGON
redefineperimeter
endcreate
makefeature
diagonal, side1, side2 : REALperimeter : REAL
-- Perimeter length.do Result := 2 ∗ (side1 + side2 ) end
invariant
vertex_count = 4end
side1
side2diagonal
![Page 38: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/38.jpg)
38
Inheritance, typing and polymorphism
(POLYGON)
(RECTANGLE)
p
r
"
Assume: p : POLYGON ; r : RECTANGLE ; t : TRIANGLE x : REAL
Permitted: x := p.perimeterx := r.perimeterx := r.diagonalp := r
NOT permitted:
x := p.diagonal -- Even just after p := r ! r := p
![Page 39: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/39.jpg)
39
Dynamic binding
What is the effect of the following (if some_test is true)?
if some_test thenp := r
elsep := t
endx := p.perimeter
Redefinition: A class may change an inherited feature, as with POLYGON redefining perimeter.
Polymorphism: p may have different forms at run-time.
Dynamic binding: Effect of p.perimeter depends on run-time form of p.
![Page 40: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/40.jpg)
40
Definitions (Dynamic binding)
Dynamic binding (a semantic rule):Any execution of a feature call will use the version of the feature best adapted to the type of the target object
![Page 41: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/41.jpg)
41
Binding and typing
(For a call xf )
Static typing: The guarantee that there is at least one version for f
Dynamic binding: The guarantee that every call will use the most appropriate version of f
![Page 42: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/42.jpg)
42
Without dynamic binding?
display (f : FIGURE)do
if “f is a CIRCLE” then...
elseif “f is a POLYGON” then...
endend
and similarly for all other routines!
Tedious; must be changed whenever there’s a new figure type
![Page 43: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/43.jpg)
43
With inheritance and associated techniques
With:
Initialize:
and:
Then just use:
f : FIGUREc : CIRCLEp : POLYGON
create c.make (...)create p.make (...)
if ... thenf := c
elsef := p
end
f.move (...)f.rotate (...)f.display (...)
-- and so on for every-- operation on f !
![Page 44: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/44.jpg)
44
Inheritance: summary 1
Type mechanism: lets you organize our data abstractions into taxonomies
Module mechanism: lets you build new classes as extensions of existing ones
Polymorphism: Flexibility with type safety
Dynamic binding: automatic adaptation of operation to target, for more modular software architectures
![Page 45: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/45.jpg)
45
Redefinition
deferred class MOVING featureorigin : COORDINATEdestination : COORDINATEposition : COORDINATEpolycursor : LIST [COORDINATE]update_coordinates
-- Update origin and destination.do
[…]origin := destinationpolycursor.forthdestination := polycursor.item[…]
end[…]
end
polycursor.i_th (i)
polycursor.i_th (i + 1)
![Page 46: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/46.jpg)
46
Redefinition 2: LINE_VEHICLEdeferred class LINE_VEHICLE inherit
VEHICLEredefine update_coordinates end
featurelinecursor : LINE_CURSORupdate_coordinates
-- Update origin and destination.do
[…]origin := destinationpolycursor.forthif polycursor.after then
linecursor.forthcreate polycursor.make (linecursor.item.polypoints)polycursor.start
enddestination := polycursor.item
end
polycursor.i_th(i)
polycursor.i_th (i + 1)
![Page 47: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/47.jpg)
47
Dynamic binding
What is the effect of the following (assuming some_test true)?m : MOVING, l : LINE_VEHICLE, t : TAXI
if some_test thenm := l
elsem := t
endm.update_coordinates
Redefinition: A class may change an inherited feature, as with LINE_VEHICLE redefining update_coordinates.
Polymorphism: m may have different forms at run-time.
Dynamic binding: Effect of m.update_coordinates depends on run-time form of m
![Page 48: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/48.jpg)
48
Dynamic binding
*TAXI
EVENT_TAXI DISPATCHER_TAXI
busy
take
take*
take
There are multiple versions of take.
inherits from
* deferred
![Page 49: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/49.jpg)
49
Extending the basic notion of class
LIST_OF_CARS
SET_OF_CARS
LINKED_LIST_OF_CARS
LIST_OF_CITIES
LIST_OF_PERSONS
Abstraction
Specialization
Type parameterization Type parameterization
Genericity
Inheritance
![Page 50: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/50.jpg)
50
Extending the basic notion of class
LIST_OF_CARS
SET_OF_CARS
LINKED_LIST_OF_CARS
LIST_OF_CITIES
LIST_OF_PERSONS
LINKED_LIST_OF_CITIES
SET_OF_PERSONS
Genericity
Inheritance
![Page 51: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/51.jpg)
51
Conformance
Defined earlier for non-generically derived types:
![Page 52: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/52.jpg)
52
Polymorphic data structures
fleet: LIST [VEHICLE]v: VEHICLE
extend (v : G) -- Add a new occurrence of v.
…fleet.extend (v)fleet.extend (cab)
(TAXI) (TAXI)(TRAM) (TRAM) (BUS)
![Page 53: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/53.jpg)
53
Definition (Polymorphism, adapted)
An attachment (assignment or argument passing) is polymorphic if its target entity and source expression have different types.
An entity or expression is polymorphic if – as a result of polymorphic attachments – it may at runtime become attached to objects of different types.
A container data structure is polymorphic if it may contain references to objects of different types.
Polymorphism is the existence of these possibilities.
![Page 54: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/54.jpg)
54
What we have seen
The basics of fundamental O-O mechanisms: Inheritance Polymorphism Dynamic binding Static typing Genericity
![Page 55: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/55.jpg)
55
Our program for the second part
Reminder on genericity, including constrained
Inheritance: deferred classesInheritance: what happens to contracts?
Inheritance: how do we find the actual type of an object?
Still to see about inheritance after this lecture: multiple inheritance, and various games such as renaming
![Page 56: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/56.jpg)
56
Genericity (reminder)
Unconstrained
LIST [G]e.g. LIST [INTEGER], LIST [PERSON]
Constrained
HASH_TABLE [G ―> HASHABLE]
VECTOR [G ―> NUMERIC ]
![Page 57: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/57.jpg)
57
A generic class (reminder)
class LIST [ G ] featureextend (x : G ) ...last : G ...
end
Formal generic parameter
Actual generic parameterTo use the class: obtain a generic derivation, e.g.
cities : LIST [ CITY ]
![Page 58: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/58.jpg)
58
Using generic derivations (reminder)
cities : LIST [CITY ]people : LIST [PERSON]c : CITYp : PERSON...
cities.extend (c)people.extend (p)
c := cities.lastc.some_city_operation
STATIC TYPINGThe compiler will reject:
people.extend (c)
cities.extend (p)
![Page 59: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/59.jpg)
59
Genericity: summary 1
Type extension mechanism
Reconciles flexibility with type safety
Enables us to have parameterized classes
Useful for container data structures: lists, arrays, trees, …
“Type” now a bit more general than “class”
![Page 60: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/60.jpg)
60
Definition: Type
We use types to declare entities, as in
x : SOME_TYPE
With the mechanisms defined so far, a type is one of:
A non-generic classe.g. METRO_STATION
A generic derivation, i.e. the name of a class followed by a list of types, the actual generic parameters, in brackets
e.g. LIST [METRO_STATION ]LIST [ARRAY [METRO_STATION ]]
![Page 61: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/61.jpg)
61
Combining genericity with inheritance
LIST_OF_CARS
SET_OF_CARS
LINKED_LIST_OF_CARS
LIST_OF_CITIES
LIST_OF_PERSONS
Abstraction
Specialization
Type parameterization Type parameterization
Genericity
Inheritance
![Page 62: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/62.jpg)
62
Genericity + inheritance 1: Constrained genericity
class VECTOR [G ] featureplus alias "+" (other : VECTOR [G]): VECTOR [G]
-- Sum of current vector and other.require
lower = other.lowerupper = other.upper
locala, b, c: G
do... See next ...
end... Other features ...
end
![Page 63: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/63.jpg)
63
Adding two vectors
i a b c=+
+ =u v w
12
![Page 64: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/64.jpg)
64
Constrained genericity
Body of plus alias "+":
create Result.make (lower, upper)
from i := lower
untili > upper
loopa := item (i )b := other.item (i )c := a + b -- Requires “+” operation on G!Result.put (c, i )i := i + 1
end
![Page 65: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/65.jpg)
65
The solution
Declare class VECTOR as
class VECTOR [G –> NUMERIC ] feature... The rest as before ...
end
Class NUMERIC (from the Kernel Library) provides features plus alias "+", minus alias "-"and so on.
![Page 66: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/66.jpg)
66
Improving the solution
Make VECTOR itself a descendant of NUMERIC,effecting the corresponding features:
class VECTOR [G –> NUMERIC ] inheritNUMERIC
feature... Rest as before, including infix "+"...
endThen it is possible to define
v : VECTOR [INTEGER ]vv : VECTOR [VECTOR [INTEGER ]]vvv : VECTOR [VECTOR [VECTOR [INTEGER ]]]
![Page 67: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/67.jpg)
67
Combining genericity with inheritance
LIST_OF_CARS
SET_OF_CARS
LINKED_LIST_OF_CARS
LIST_OF_CITIES
LIST_OF_PERSONS
Abstraction
Specialization
Type parameterization Type parameterization
Genericity
Inheritance
![Page 68: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/68.jpg)
68
Genericity + inheritance 2: Polymorphic data structures
figs : LIST [FIGURE ]p1, p2 : POLYGONc1, c2 : CIRCLEe : ELLIPSE
(POLYGON) (CIRCLE) (POLYGON)(CIRCLE) (ELLIPSE)
class LIST [G ] featureextend (v : G) do …
endlast : G…
end
figs.extend (p1 ) ; figs.extend (c1 ) ; figs.extend (c2 )figs.extend (e ) ; figs.extend (p2 )
![Page 69: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/69.jpg)
69
Example hierarchy
FIGURE*
OPEN_ FIGURE
*CLOSED_ FIGURE
*
SEGMENT POLYLINE POLYGONELLIPSE
CIRCLE
RECTANGLETRIANGLE
SQUARE
center * display *rotate*
perimeter *
perimeter +perimeter +
perimeter ++ diagonal
......
perimeter ++
++
side2
* deferred
+ effective
++ redefined
perimeter ++
side1
![Page 70: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/70.jpg)
70
Another application: undoing-redoing
This example again uses a powerful polymorphic data structureThis will only be a sketch; we’ll come back to the details in the agent lecture
References:
Chapter 21 of my Object-Oriented Software Construction, Prentice Hall, 1997
Erich Gamma et al., Design Patterns, Addison –Wesley, 1995: “Command pattern”
![Page 71: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/71.jpg)
71
The problem
Enabling users of an interactive system to cancel the effect of the last command
Often implemented as “Control-Z”
Should support multi-level undo-redo (“Control-Y”), with no limitation other than a possible maximum set by the user
![Page 72: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/72.jpg)
72
Our working example: a text editor
Notion of “current line”.Assume commands such as:
Remove current line Replace current line by specified text Insert line before current position Swap current line with next if any “Global search and replace” (hereafter GSR):
replace every occurrence of a specified string by another
...
This is a line-oriented view for simplicity, but the discussion applies to more sophisticated views
![Page 73: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/73.jpg)
73
A straightforward solution
Before performing any operation, save entire state
In the example: text being edited,current position in text
If user issues “Undo” request, restore entire state as last saved
But: huge waste of resources, space in particular
Intuition: only save the “diff” between states.
![Page 74: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/74.jpg)
74
Keeping the history of the session
The history list:
history : TWO_WAY_LIST [COMMAND]
Removal SwapInsertion Insertion Insertion
Oldest Most recent
![Page 75: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/75.jpg)
75
What’s a “command” object?
A command object includes information about one execution of a command by the user, sufficient to:
Execute the command Cancel the command if requested later
For example, in a Removal command object, we need:
• The position of the line being removed
• The content of that line!
![Page 76: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/76.jpg)
76
General notion of command
deferred class COMMAND feature
execute-- Carry out one execution of this command.
undo-- Cancel an earlier execution of this command.
end
deferred
: doneend
deferredend
done: BOOLEAN -- Has this command been executed?
ensurealready: done
requirealready: done
![Page 77: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/77.jpg)
77
Command class hierarchy
execute*
undo*
…
execute+
undo+
line: STRINGindex: INTEGER...
execute+
undo+
index...
*COMMAND
+REMOVAL
+INSERTION
* deferred
+ effective
![Page 78: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/78.jpg)
78
Underlying class (from business model)
class EDIT_CONTROLLER featuretext : TWO_WAY_LIST [STRING]remove
-- Remove line at current position.require
not offdo
text.removeend
put_right (line : STRING)-- Insert line after current position.
requirenot after
dotext.put_right (line)
end
... also item, index, go_ith, put_left ...end
![Page 79: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/79.jpg)
79
A command class (sketch, no contracts)
class REMOVAL inherit COMMAND featurecontroller : EDIT_CONTROLLER
-- Access to business model.line : STRING
-- Line being removed.index : INTEGER
-- Position of line being removed.
execute-- Remove current line and remember it.
do line := controller.item ; index := controller.indexcontroller.remove ; done := True
end
undo-- Re-insert previously removed line.
do controller.go_i_th (index)controller.put_left (line)
endend
![Page 80: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/80.jpg)
80
A polymorphic data structure:
history : TWO_WAY_LIST [COMMAND]
Removal SwapInsertion Insertion Insertion
Oldest Most recent
The history list
![Page 81: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/81.jpg)
81
Reminder: the list of figuresclass
LIST [G] feature
...last: G do ...extend (x: G) do ...
end
fl : LIST [FIGURE]r : RECTANGLEs : SQUAREt : TRIANGLEp : POLYGON...fl.extend (p); fl.extend (t); fl.extend (s); fl.extend (r)fl.last.display
(SQUARE)
(RECTANGLE)
(TRIANGLE)
(POLYGON)
fl
![Page 82: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/82.jpg)
82
Reminder: the list of figures
figs : LIST [FIGURE ]p1, p2 : POLYGONc1, c2 : CIRCLEe : ELLIPSE
class LIST [G ] featureextend (v : G) do …
endlast : G…
end
figs.extend (p1 ) ; figs.extend (c1 ) ; figs.extend (c2 )figs.extend (e ) ; figs.extend (p2 )
(POLYGON) (CIRCLE) (POLYGON)(CIRCLE) (ELLIPSE)
![Page 83: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/83.jpg)
83
A polymorphic data structure:
history : TWO_WAY_LIST [COMMAND]
Removal SwapInsertion Insertion Insertion
Oldest Most recent
The history list
![Page 84: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/84.jpg)
84
Executing a user command
decode_user_request
if “Request is normal command” then“Create command object c corresponding to user request”history.extend (c)c.execute
elseif “Request is UNDO” thenif not history.before then -- Ignore excessive requests
history.item.undohistory.back
endelseif “Request is REDO” then
if not history.is_last then -- Ignore excessive requestshistory.forthhistory. item.execute
endend
item
Pseudocode, see implementation next
Removal SwapInsertion Insertion
![Page 85: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/85.jpg)
85
Command class hierarchy
execute*
undo*
…
execute+
undo+
line: STRINGindex: INTEGER...
execute+
undo+
index...
*COMMAND
+REMOVAL
+INSERTION
* deferred
+ effective
![Page 86: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/86.jpg)
86
Example hierarchy
FIGURE*
OPEN_ FIGURE
*CLOSED_ FIGURE
*
SEGMENT POLYLINE POLYGONELLIPSE
CIRCLE
RECTANGLETRIANGLE
SQUARE
center * display *rotate*
perimeter *
perimeter +perimeter +
perimeter ++ diagonal
......
perimeter ++
++
side2
* deferred
+ effective
++ redefined
perimeter ++
side1
![Page 87: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/87.jpg)
87
Enforcing a type: the problem
fl.store (“FN")...
-- Two years later:fl := retrieved (“FN") -- See nextx := fl.last -- [1]print (x.diagonal ) -- [2]
What’s wrong with this?
If x is declared of type RECTANGLE, [1] is invalid.If x is declared of type FIGURE, [2] is invalid.
![Page 88: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/88.jpg)
88
Object-TestLocal
Enforcing a type: the Object Test
if attached {RECTANGLE} fl.retrieved ("FN") as r then
print (r.diagonal )
… Do anything else with r, guaranteed… to be non void and of dynamic type RECTANGLE
elseprint ("Too bad.")
end
Expression to be tested
SCOPE of the Object-Test Local
![Page 89: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/89.jpg)
89
Earlier mechanism: assignment attempt
f : FIGUREr : RECTANGLE...fl.retrieve ("FN")f := fl.last
r ?= f
if r /= Void thenprint (r.diagonal )
elseprint ("Too bad.")
end
![Page 90: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/90.jpg)
90
Assignment attempt
x ?= y
with
x : A
Semantics: If y is attached to an object whose type conforms to
A, perform normal reference assignment.
Otherwise, make x void.
![Page 91: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/91.jpg)
91
The role of deferred classes
Express abstract concepts independently of implementation
Express common elements of various implementations
Terminology: Effective = non-deferred(i.e. fully implemented)
![Page 92: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/92.jpg)
92
In e.g. LIST:
forth
deferred
end
A deferred feature
ensureindex = old index
requirenot after
![Page 93: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/93.jpg)
93
Deferred!
In the same class
search (x : G)-- Move to first position after current-- where x appears, or after if none.
dofrom until after or else item = x loop
forthend
end
“Programs with holes”
Mixing deferred and effective features
Effective!
![Page 94: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/94.jpg)
94
“Don’t call us, we’ll call you!”
A powerful form of reuse: The reusable element defines a general scheme Specific cases fill in the holes in that scheme
Combine reuse with adaptation
![Page 95: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/95.jpg)
95
Applications of deferred classes
Analysis and design, top-down
Taxonomy
Capturing common behaviors
![Page 96: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/96.jpg)
96
Deferred classes in EiffelBase
CONTAINER*
BOX* COLLECTION* TRAVERSABLE*
FINITE* INFINITE*
BOUNDED* UNBOUNDED* COUNTABLE*
RESIZABLE*
BAG* SET* HIERARCHICAL* LINEAR*
TABLE* ACTIVE* INTEGER_ INTERVAL
* BILINEAR*
INDEXABLE* CURSOR_ STRUCTURE
* DISPENSER* SEQUENCE*
ARRAY STRING HASH_TABLE STACK* QUEUE*
… …
* deferred
![Page 97: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/97.jpg)
97
Java and .NET solution
Single inheritance only for classesMultiple inheritance from interfaces
An interface is like a fully deferred class, with no implementations (do clauses), no attributes (and also no contracts)
![Page 98: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/98.jpg)
98
Multiple inheritance: Combining abstractions
COMPARABLE NUMERIC
STRING COMPLEX
INTEGER
REAL
<, <=,>, >=, …
+, –, ∗, / …
(total order relation)
(commutative ring)
![Page 99: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/99.jpg)
99
How do we write COMPARABLE ?
deferred class COMPARABLE feature
end
less alias "<" (x : COMPARABLE ): BOOLEANdeferredend
less_equal alias "<=" (x : COMPARABLE ): BOOLEANdo
Result := (Current < x or (Current = x))end
greater alias ">" (x : COMPARABLE ): BOOLEANdo Result := (x < Current) end
greater_equal alias ">=" (x : COMPARABLE): BOOLEANdo Result := (x <= Current) end
![Page 100: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/100.jpg)
100
Deferred classes vs Java interfaces
Interfaces are “entirely deferred”:Deferred features only
Deferred classes can include effective features, which rely on deferred ones, as in the COMPARABLE example
Flexible mechanism to implement abstractions progressively
![Page 101: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/101.jpg)
101
Applications of deferred classes
Abstraction
Taxonomy
High-level analysis and design
…
![Page 102: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/102.jpg)
102
Television station example
class SCHEDULE featuresegments : LIST [SEGMENT]
end
Source: Object- Oriented Software Construction, 2nd edition, Prentice Hall
![Page 103: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/103.jpg)
103
Schedules
notedescription :“ 24-hour TV schedules”
deferred class SCHEDULE feature
segments : LIST [SEGMENT ]-- Successive segments.
deferredend
air_time : DATE-- 24-hour period-- for this schedule.
deferredend
set_air_time (t : DATE)-- Assign schedule to-- be broadcast at time t.
requiret.in_future
deferredensure
air_time = tend
print-- Produce paper version.
deferredend
end
![Page 104: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/104.jpg)
104
Segment
notedescription : "Individual fragments of a schedule "
deferred class SEGMENT featureschedule : SCHEDULE
deferred end-- Schedule to which-- segment belongs.index : INTEGER deferred end-- Position of segment in-- its schedule.starting_time, ending_time :
INTEGER deferred end-- Beginning and end of-- scheduled air time.next: SEGMENT deferred end-- Segment to be played-- next, if any.
sponsor : COMPANY deferred end-- Segment’s principal sponsor.
rating : INTEGER deferred end-- Segment’s rating (for-- children’s viewing etc.).
… Commands such aschange_next, set_sponsor,set_rating, omitted …
Minimum_duration : INTEGER = 30-- Minimum length of segments,-- in seconds.
Maximum_interval : INTEGER = 2-- Maximum time between two-- successive segments, in seconds.
![Page 105: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/105.jpg)
105
Segment (continued)
invariant
in_list: (1 <= index) and (index <= schedule.segments.count)
in_schedule: schedule.segments.item (index) = Currentnext_in_list: (next /= Void ) implies
(schedule.segments.item (index + 1 ) = next)
no_next_iff_last: (next = Void ) = (index = schedule.segments.count)non_negative_rating: rating >= 0positive_times: (starting_time > 0 ) and (ending_time > 0)sufficient_duration:
ending_time – starting_time >= Minimum_durationdecent_interval :
(next.starting_time) - ending_time <= Maximum_intervalend
![Page 106: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/106.jpg)
106
Commercial
notedescription:
"Advertizing segment "deferred class COMMERCIALinherit
SEGMENT rename sponsor as advertizer end
featureprimary : PROGRAM deferred
-- Program to which this-- commercial is attached.
primary_index : INTEGERdeferred-- Index of primary.
set_primary (p : PROGRAM)-- Attach commercial to p.
requireprogram_exists: p /= Voidsame_schedule:
p.schedule = schedulebefore:
p.starting_time <= starting_timedeferredensure
index_updated:primary_index = p.index
primary_updated: primary = pend
![Page 107: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/107.jpg)
107
Commercial (continued)
invariantmeaningful_primary_index: primary_index = primary.indexprimary_before: primary.starting_time <= starting_timeacceptable_sponsor: advertizer.compatible (primary.sponsor)acceptable_rating: rating <= primary.rating
end
![Page 108: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/108.jpg)
108
deferred classVAT
inheritTANK
featurein_valve, out_valve : VALVE
-- Fill the vat.require
in_valve.openout_valve.closed
deferredensure
in_valve.closedout_valve.closedis_full
end
empty, is_full, is_empty, gauge, maximum, ... [Other features] ...
invariantis_full = (gauge >= 0.97 * maximum) and (gauge <= 1.03 * maximum)
end
Chemical plant example
![Page 109: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/109.jpg)
109
Contracts and inheritance
Issue: what happens, under inheritance, to
Class invariants?
Routine preconditions and postconditions?
![Page 110: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/110.jpg)
110
Invariants
Invariant Inheritance rule: The invariant of a class automatically includes the
invariant clauses from all its parents, “and”-ed.
Accumulated result visible in flat and interface forms.
![Page 111: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/111.jpg)
111
Contracts and inheritance
rrequireγ
ensureδ
rrequireα
ensureβ
a1 : Aa1.r (…)…
Correct call in C:if a1.α then
a1.r (...)-- Here a1.β holds
end
r ++
C A
D B
client of
inherits from
++ redefinition
![Page 112: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/112.jpg)
112
Assertion redeclaration rule
When redeclaring a routine, we may only:
Keep or weaken the precondition
Keep or strengthen the postcondition
![Page 113: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/113.jpg)
113
A simple language rule does the trick!
Redefined version may have nothing (assertions kept by default), or
require else new_preensure then new_post
Resulting assertions are: original_precondition or new_pre
original_postcondition and new_post
Assertion redeclaration rule in Eiffel
![Page 114: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/114.jpg)
114
What we have seen
Deferred classes and their role in software analysis and design
Contracts and inheritance
Finding out the “real” type of an object
![Page 115: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/115.jpg)
115
Combining abstractions
Given the classes
TRAIN_CAR, RESTAURANT
how would you implement a DINER?
![Page 116: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/116.jpg)
116
Examples of multiple inheritance
Combining separate abstractions:
Restaurant, train car Calculator, watch Plane, asset Home, vehicle Tram, bus
![Page 117: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/117.jpg)
117
Warning
Forget all you have heard!Multiple inheritance is not the works of the devilMultiple inheritance is not bad for your teeth
(Even though Microsoft Word apparently does not like it:
)
![Page 118: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/118.jpg)
118
This is repeated, not just multiple inheritance
A
D
B C
A
D
Not the basic case!(Although it does arise often; why?)
![Page 119: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/119.jpg)
119
Another warning
The language part of this lecture are Eiffel-oriented
Java and C# mechanisms (single inheritance from classes, multiple inheritance from interfaces) will also be discussed
C++ also has multiple inheritance, but I will not try to describe it
![Page 120: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/120.jpg)
120
Composite figures
![Page 121: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/121.jpg)
121
Multiple inheritance: Composite figures
A composite figure
Simple figures
![Page 122: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/122.jpg)
122
Defining the notion of composite figure
COMPOSITE_FIGURE
centerdisplayhiderotatemove…
countputremove…
FIGURELIST
[FIGURE ]
![Page 123: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/123.jpg)
123
In the overall structure
COMPOSITE_FIGURE
FIGURE LIST [FIGURE ]
OPEN_FIGURE
CLOSED_FIGURE
SEGMENT POLYLINE POLYGON ELLIPSE
RECTANGLE
SQUARE
CIRCLETRIANGLE
perimeter+
perimeter*
perimeter++
diagonal
perimeter++
perimeter++
perimeter+
![Page 124: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/124.jpg)
124
A composite figure as a list
Cursor
item
forth
after
![Page 125: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/125.jpg)
125
Composite figures
class COMPOSITE_FIGURE inheritFIGURELIST [FIGURE]
featuredisplay
-- Display each constituent figure in turn.do
acrossCurrent as c loop
c.item.displayendend
... Similarly for move, rotate etc. ...end
Requires dynamic binding
![Page 126: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/126.jpg)
126
Going one level of abstraction higher
A simpler form of procedures display, move etc. can be obtained through the use of iterators
Use agents for that purpose
![Page 127: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/127.jpg)
127
Multiple inheritance: Combining abstractions
COMPARABLE NUMERIC
STRING COMPLEX
INTEGER
REAL
<, <=,>, >=, …
+, –, ∗, / …
(total order relation)
(commutative ring)
![Page 128: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/128.jpg)
128
The Java-C# solution
No multiple inheritance for classes
“Interfaces”: specification only (but no contracts) Similar to completely deferred classes (with no
effective feature)
A class may inherit from: At most one class Any number of interfaces
![Page 129: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/129.jpg)
129
Multiple inheritance: Combining abstractions
COMPARABLE NUMERIC
STRING COMPLEX
INTEGER
REAL
<, <=,>, >=, …
+, –, ∗, / …
(total order relation)
(commutative ring)
![Page 130: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/130.jpg)
130
How do we write COMPARABLE?
deferred class COMPARABLE [G ] feature
end
less alias "<" (x : COMPARABLE [G ]): BOOLEANdeferredend
less_equal alias "<=" (x : COMPARABLE [G ]): BOOLEANdo
Result := (Current < x or (Current = x))end
greater alias ">" (x : COMPARABLE [G ]): BOOLEANdo Result := (x < Current) end
greater_equal alias ">=" (x : COMPARABLE [G ]): BOOLEANdo Result := (x <= Current) end
![Page 131: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/131.jpg)
131
Lessons from this example
Typical example of program with holes
We need the full spectrum from fully abstract (fully deferred) to fully implemented classes
Multiple inheritance is there to help us combine abstractions
![Page 132: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/132.jpg)
132
A common Eiffel library idiom
class ARRAYED_LIST [G ] inheritLIST [G ] ARRAY [G ]
feature… Implement LIST features using ARRAY features …
end
For example:i_th (i : INTEGER ): G
-- Element of index `i’.do
Result := item (i )end
Feature of ARRAY
![Page 133: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/133.jpg)
133
Could use delegation instead
class ARRAYED_LIST [G ] inheritLIST [G ]
featurerep : LIST [G ]… Implement LIST features using ARRAY features
applied to rep …
end For example:i_th (i : INTEGER ): G
-- Element of index `i’.do
Result := rep item (i)end
![Page 134: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/134.jpg)
134
Non-conforming inheritance
classARRAYED_LIST [G ]
inheritLIST [G ]
ARRAY [G ]
feature… Implement LIST features using ARRAY features
…end
inherit {NONE }
ARRAYLIST
ARRAYED_LIST
Non-conforminginheritance
![Page 135: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/135.jpg)
135
Multiple inheritance: Name clashes
f
C
f A B
?
![Page 136: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/136.jpg)
136
Resolving name clashes
f
rename f as A_f
C
f A B
A_f, f
![Page 137: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/137.jpg)
137
Consequences of renaming
a1 : Ab1 : Bc1 : C...c1.fc1.A_fa1.fb1.f
rename f as A_f
C
f A B
A_f, f
f
Invalid: a1.A_fb1.A_f
![Page 138: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/138.jpg)
138
Are all name clashes bad?
A name clash must be removed unless it is: Under repeated inheritance (i.e. not a real clash)
Between features of which at most one is effective(i.e. others are deferred)
![Page 139: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/139.jpg)
139
Another application of renaming
Provide locally better adapted terminology.Example: child (TREE ); subwindow (WINDOW)
![Page 140: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/140.jpg)
140
Renaming to improve feature terminology
‘‘Graphical’’ features: height, width, change_height, change_width, xpos, ypos, move...‘‘Hierarchical’’ features: superwindow, subwindows, change_subwindow, add_subwindow...
class WINDOW inheritRECTANGLETREE [WINDOW]
renameparent as superwindow,children as subwindows,add_child as add_subwindow…
endfeature
...end
BUT: see style rules about
uniformity of feature names
![Page 141: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/141.jpg)
141
Feature merging
A B C
D
f +f * f *
∗ Deferred+ Effective
![Page 142: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/142.jpg)
142
Feature merging: with different names
A B C
D
h +g * f *
∗ Deferred+ Effective
Renaming
g f h f
classD
inheritA
renameg as f
endBC
renameh as f
endfeature
...end
![Page 143: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/143.jpg)
143
Feature merging: effective features
A B C
D
f +f + f +
∗ Deferred+ Effective-- Undefine
f --f --
![Page 144: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/144.jpg)
144
Undefinition
deferred classT
inheritS
undefine v end
feature
...
end
![Page 145: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/145.jpg)
145
Merging through undefinition
classD
inheritA
undefine f endBC
undefine f endfeature
...end
A B C
D
f +f + f +
f --f --
∗ Deferred+ Effective-- Undefine
![Page 146: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/146.jpg)
146
Merging effective features with different names
A B C
D
h +f + g +
f --
f --
classD
inheritAundefine f end
Brename
g as fundefine f end
Crename
h as fend
feature ... end
h f
g f
![Page 147: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/147.jpg)
147
Acceptable name clashes
If inherited features have all the same names, there is no harmful name clash if: They all have compatible signatures At most one of them is effective
Semantics of such a case: Merge all features into one If there is an effective feature, it imposes its
implementation
![Page 148: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/148.jpg)
148
Feature merging: effective features
a1: A b1: B c1: C d1: Da1.g b1.f c1.h d1.f
A B C
D
g+ f+ h+
g f h ff- f-
![Page 149: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/149.jpg)
149
A special case of multiple inheritance
Allow a class to have two or more parents.
Examples that come to mind: ASSISTANT inherits from TEACHER and STUDENT. TEACHER STUDENT
ASSISTANT
UNIVERSITY_MEMBER id
This is a case of repeated inheritance
????
????
![Page 150: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/150.jpg)
150
Indirect and direct repeated inheritance
A
D
B C
A
D
![Page 151: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/151.jpg)
151
Multiple is also repeated inheritance
A typical case:
copy ++
is_equal ++
copyis_equal
??
copy C_copyis_equal C_is_equal
CLIST
D
ANY
![Page 152: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/152.jpg)
152
Acceptable name clashes
If inherited features have all the same names, there is no harmful name clash if:
They all have compatible signatures At most one of them is effective
Semantics of such a case: Merge all features into one If there is an effective feature, it imposes its
implementation
![Page 153: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/153.jpg)
153
Sharing and replication
Features such as f, not renamed along any of the inheritance paths, will be shared.Features such as g, inherited under different names, will be replicated.
A
B C
D
fg
g g_b g g_c
![Page 154: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/154.jpg)
154
The need for select
A potential ambiguity arises because of polymorphism and dynamic binding:
a1 : ANYd1 : D
…
a1 := d1a.copy (…)
copy ++
is_equal ++
copy C_copyis_equal C_is_equal
CLIST
D
copyis_equalANY
![Page 155: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/155.jpg)
155
Removing the ambiguity
classD
inheritLIST [T ]
selectcopy, is_equal
end
Crename
copy as C_copy, is_equal as C_is_equal,
...end
![Page 156: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/156.jpg)
156
When is a name clash acceptable?
(Between n features of a class, all with the same name, immediate or inherited.)
They must all have compatible signatures.
If more than one is effective, they must all come from a common ancestor feature under repeated inheritance.
![Page 157: Genericity & Inheritance · 2 On the menu Two fundamental mechanisms for expressiveness and reliability: Genericity Inheritance with associated (just as important!) notions: Static](https://reader031.vdocument.in/reader031/viewer/2022021821/5af58bfe7f8b9a95468f8103/html5/thumbnails/157.jpg)
157
What we have seen
A number of games one can play with inheritance: Multiple inheritance Feature merging Repeated inheritance