Upload
vernon-riley
View
223
Download
0
Tags:
Embed Size (px)
Citation preview
OOPs
Object oriented programming
Abstract data types
Representationof type and operations in a single unit
Available for other units to create variables of the type
Possibility of hiding data structure of type and implementation of operations
Limitations of ADT andOOP extensions
Software reuse: ADTs too rigid-> inheritance
No structure to collections of ADTs-> inheritance
OOP provides class hierarchies
The three* hierarchies of OOP Inheritance:
1 - n
Instantiation1 - n
Composition1 - n
superclass
subclass
class
instance
object
instance variable
* Not including interfaces
Inheritance
Superclass – subclass Subclass inherits all methods, variables Subclass can add methods, variables Subclass can overwrite all methods, variables-> increased reusability-> structure collections of classes
Access to variables and methods
ADTs – public (global scope) or private (class scope)
Objects - public or private-plus protected (class plus subclasses)?
Design decision: info hiding vs efficiency Java adds package scope
Inheritance rules
Single inheritance (Smalltalk) – subclass has only one superclass; classes form an inheritance tree
Multiple inheritance (C++) – subclass can have multiple superclasses
Single inheritance plus interfaces (Java)
Need for multiple inheritance ‘orthogonal’ properties – the ‘diamond’ problem
Vehicle
GMVehicle KiaVehicle
GMCar GMSUV KiaCar KiaSUV
Vehicle
Car SUV
GMCar GMSUVKiaCar KiaSUV
Car, SUV properties repeated
Manufacturer properties repeated
Using multiple inheritance
Vehicle
KiaVehicleGMVehicle Car SUV
GMCar GMSUV KiaCar KiaSUV
Problems of multiple inheritance
Identifier conflict:
Class Super1
int x, y
Class Super2
double x, z
Class Sub extends Super1, Super2
Which x?
Interfaces solve the multiple inheritance problem
No variables in interfaces No method implementations in
interfaces – only protocolsBUT Weaker inheritance – no gain in code
reuse
Type checking
none (Smalltalk typeless) message compatibility
subclasses are subtypes* type compatibility – object of subtype
can be assigned to identifier declared of superclass type
dynamic type checking provides polymorphism
* note exceptions, e.g., C++
Polymorphism in method calls
class Super
method x()
class Sub1
method x()
class Sub3
method x()
class Sub2
Super a,b,c,d;
a = new Super();
b = new Sub1();
c = new Sub2();
d = new Sub3();
a.x();
b.x();
c.x();
d.x();
Polymorphism means dynamic type checking
class of object must be determined at run time methods bound to messages dynamically parameters type checked dynamically
BUT protocol can be verified statically-> purpose of abstract methods
Forced static binding
if a method cannot be overridden, it can be statically bound C++ assumes methods cannot be
overridden -> statically bound – virtual keyword causes dynamic binding
Java (and Objective C) assumes methods can be overridden -> dynamic binding – final keyword allows static binding
Implementing dynamic method invocation
Superclass method table (VMT)
-methA
-methB
Subclass method table (VMT)
-methA
-methC
Ref to parent VMT
Superclass var1;
var1 = new Subclass();
var1.methA();
var1.methB();
var1.methC(); // compile error
var1 Instance vars;Ref to class VMT
Allocation and de-allocation
What kinds of object memory allocation? Static Stack-dynamic Heap-dynamic
Heap reclamation Programmer control Garbage collection
C++ Smalltalk,Java
X
X
X X
X
X
C++
Access: Classes private, public Members private, public, protected
Extending class can change access Override access to members in parent Valuable for ‘narrowing’ access polymorphism problem
List
Stack QueueRemove some access
C++
Inheritance – partial – no single hierarchy
Efficient but complex
Java
Closer to pure object language than C++ No functions Dynamic by default One hierarchy of classes
BUT Imperative statements Primitive data types are not objects
Another ‘object’ model
Property lists / attribute-value pairs E.g., Lisp symbols: property list E.g., Javascript objects: hash table Properties are typeless – data and
methods Set of properties is dynamically varying Ideally suited to tabulation – visual
programming Are they objects? ADTs? Variant records?