Transcript wk09OOPs

OOPs
Object oriented programming
Based on ADT principles
 Representation of 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 -->
OOP 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
 Instantiation
1-n
 Composition
1-n
* Not including interfaces
superclass
subclass
class
instance
object
instance variable
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
Scope and objects - java
looking for a variable while executing a
method:
block, local, instance, class
extensions:
inner class, package, inheritance
public, protected, private
Scope & objects in java
looking for a
variable
while
executing a
method:
1.block,
2.local,
3.instance,
4.class,
5.superclass
class Nest extends Bird
{
superclass w
int x=10;
static int z=0;
class z
void doIt(int q)
instance x
{
int r = 100;
{
method r,q
int t = r+x+z+q+w;
block t
}
}
}
w in superclass, either protected or public, may be static
Scope and objects - java
extensions:
inner class - static scoping
protected, private, public(looking inward)
packages
 access to classes, methods, public variables
 importing
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
GMCar
KiaVehicle
GMSUV
KiaCar
KiaSUV
Car, SUV
properties
repeated
Vehicle
Car
GMCar
SUV
KiaCar
GMSUV
KiaSUV
Manufacturer
properties
repeated
Using multiple inheritance
Vehicle
GMVehicle
GMCar
KiaVehicle
GMSUV
Car
KiaCar
SUV
KiaSUV
Problems of multiple inheritance
 Identifier conflict:
Class Super1
Class Super2
int x, y
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 protocols
BUT
 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
Polymorphism in method calls
Super a,b,c,d;
class Super
a = new Super();
method x()
class Sub1
method x()
class Sub2
b = new Sub1();
class Sub3
method x()
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)
Superclass var1;
var1 = new Subclass();
var1.methA();
-methA
-methB
var1.methB();
var1.methC(); // compile error
Subclass method table (VMT)
-methA
var1
Instance vars;
Ref to class VMT
-methC
Ref to parent VMT
Allocation and de-allocation
 What kinds of object memory
allocation?
C++
Smalltalk,Java
 Static
 Stack-dynamic
 Heap-dynamic
X
X
X
X
 Heap reclamation
 Programmer control
 Garbage collection
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
List
 polymorphism problem
Remove some access
Stack
Queue
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
Smalltalk - pure OOP
 every statement is a message with an
object recipient and method
invocation
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?