Basic Mechanism of OOPL

Basic Mechanism of
Object-Oriented
Programming Language

2009-09-11 : Released
2009-09-14 : Fixed

makoto kuwata <kwa@kuwata-lab.com>
http://www.kuwata-lab.com/

copyright© 2009 kuwata-lab.com all right reserved.

Purpose

✤ Describes basic mechanism of Object-Oriented
Programming Language (OOPL)
✤ Not only Perl but also Python, Ruby, Java, ...

✤ You must be familiar with terms of Object-Oriented
✤ Class, Instance, Method, Override, Overload, ...


Agenda

✤ Part 1. Basics about OOPL Mechanism
✤ Part 2. More about OOPL Mechanism
✤ Part 3. Case Study


Part 1.
Basics about OOPL Mechanism


Overview
Function
Class obj Method Tbl func (self) {
Variable .....
m1 }
m2
Z: 123 m3
func (self) {
.....
Instance obj Class obj Method Tbl }
m2
x: 10 m3 func (self) {
y: 20 Z: 456 m4 .....
}


Instance Object
Pointer to
Class object
✤ Instance variables + Is-a pointer
✤ Instance object knows "what I am"

Variable Instance obj Class obj

x: 10

Hash data (in script y: 20
lang) or Struct data
(in Java or C++)

Class Object
Class obj
✤ Class variables Method Table
( + Is-a pointer)
+ Parent pointer
Z: 30
+ Method Table
Class obj
Instance methods Method Table
belong to Class

Z: 35

Method Lookup Table
✤ Method signatures(≒names) + function pointers

✤ May have pointer to parent method table

Class obj Method Table func (self) {
print "hello";
m1 }
m2
m3 func (self, x) {
return x + 1;
}


Method Function

✤ Instance object is passed as hidden argument
OOPL non-OOPL
class Point { def move(self, x, y) {
var x=0, y=0; self['x'] = x;
def move(x, y) { self['y'] = y;
this.x = x; }
this.y = y;
almost
} equiv. p = {isa: Point, x: 0, y: 0};
} func = lookup(p, 'move');
p = new Point(); func(p, 10, 20);
p.move(10, 20);

Difference bet. method and function

✤ Method requires instance object
✤ Typically, instance obj is passed as 1st argument

✤ Method call is dynamic, function call is static
✤ Method signature(≒name) is determined statically

✤ Method lookup is performed dynamically
(This is why method call is slower than function call)


Overview (again)
Function
Class obj Method Tbl func (self) {
Variable .....
m1 }
m2
Z: 123 m3
func (self) {
.....
Instance obj Class obj Method Tbl }
m2
x: 10 m3 func (self) {
y: 20 Z: 456 m4 .....
}


Conslusion

✤ Instance object knows "what I am" (by is-a pointer)
✤ Instance variables belong to instance object
✤ Instance methods belong to class object
✤ function-call is static, method-call is dynamic


Part 2.
More about OOPL Mechanism


Method Signature

✤ Method name + Argument types (+ Return type)
(in static language)
✤ Or same as Method name (in dynamic language)

Example (Java):
Method Declaration Method Signature

void hello(int v, char ch) hello(IC)V
void hello(String s) hello(Ljava.lang.String;)V


Method Overload

✤ One method name can have different method
signature
Class obj Method Table
hello(IC)
hello(Ljava.lang.String;)


Method Override

✤ Child class can deﬁne methods which has same
method signature as method in parent class
Parent Class Method Table
hello(IC)

Child Class Method Table
:

Super

✤ 'Super' skips method table lookup once

def m1() { Class obj
super.m1();
Method Table
}
m1
:
Instance obj Class obj
Method Table
x: 10 X m1
:

Polymorphism (1)
not used
✤ Polymorphism depends on ... used
✤ Receiver object's data type Animal a;
a = new Dog(); a.bark();
✤ Variable data type
a = new Cat(); a.bark();
Determined dynamically
Instance obj Class obj Method Tbl Method Func
bark(...) func (self) {
.....
: :
}
: :


Polymorphism (2)
✤ Polymorphism depends on ...
void bark(Object o) { ... }
✤ Data type of formal args
a.bark("Wee!");
✤ Data type of actual args

Determined statically

Instance obj Class obj Method Tbl Method Func
bark(...) func (self) {
.....
: :
}
: :


"Object" class vs. "Class" class (1)
class Class
"Class" extends "Object"
extends Object {...}

class Foo "Object" class
extends Object {...}

NULL "Class" class

Instance obj
"Foo" class

x: 10
y: 20 "Foo" extends "Object"

"Object" class vs. "Class" class (2)
Object = new Class() "Object" is-a "Class"
Foo = new Class()
Instobj = new Foo() "Object" class "Class" is-a "Class"

Instance is-a "Foo" NULL "Class" class

Instance obj
"Foo" class

x: 10
y: 20 "Foo" is-a "Class"

Conclusion (1)

✤ Method Signature = Method Name + Arg Types
✤ Method Overload : Same method name can have
different method signature
✤ Method Override : Child class can have same
method signature as parent class
✤ Super : Skips current class when method lookup


Conclusion (2)

✤ Polymorphism
✤ Depends on Receiver's data type, Method Name, and
Temporary Args' data type

✤ Not depends on Variable data type and Actual Args'
data type

✤ Relation between "Object" class and "Class" class is
complicated


Part 3.
Case Study


Case Study: Ruby

from ruby.h: from ruby.h:
struct RBasic { struct RClass {
unsigned long ﬂags; struct RBasic basic;
VALUE klass; struct st_table *iv_tbl;
}; struct st_table *m_tbl;
Is-a pointer
VALUE super;
struct RObject { };
struct RBasic basic; Parent pointer
struct st_table *iv_tbl;
};
Method table
Instance variables


Case Study: Perl
package Point;
sub new {
my $classname = shift @_; bless() binds hash data
my ($x, $y) = @_; with class name
my $this = {x=>$x, y=>$y}; (instead of is-a pointer)
return bless $this, $classname;
}
sub move_to {
my $this = shift @_; Instance object is the
my ($x, $y) = @_; ﬁrst argument of
$this->{x} = $x; instance method
$this->{y} = $y;
} copyright© 2009 kuwata-lab.com all right reserved.

Case Study: Python
class Point(object):
def __init__(self, x=0, y=0):
self.x = x Instance object is the
self.y = y ﬁrst argument of
instance method
def move_to(self, x, y):
self.x = x
self.y = y
Possible to call instance
p = Point(0, 0) method as function
p.move_to(10, 20)
Point.move_to(p, 10, 20) Python uses function as method, and
Ruby uses method as function.

Case Study: Java
Class obj
Method Table
m1 func (this) { ... }

m2
func (this) { ... }

Class obj Copy parent entries
Method Table not to follow parent
table (for performance)
m1
m2
m3 func (this) { ... }

Case Study: JavaScript (1)
/// (1)
✤ instance.__proto__ points prototype function Animal(name) {
object (= Constructor.prototype) this.name = name;
}
✤ Trace __proto__ recursively
/// (2)
(called as 'prototype chain') Animal.prototype.bark =
function() {
('__proto__' property is anim alert(this.name); }
available on Firefox)
name /// (3)
var anim =
__proto__
new Animal("Doara");
(3)
Animal prototype
(1) (2)
prototype bark prototype
this.name = name; __proto__ alert(this.name);


Case Study: JavaScript (2)
/// (4) /// (5)
function Dog(name) { Dog.prototype.bark2 =
Animal.call(this, name); dog function() {
} name alert("BowWow"); };
Dog.prototype = anim; /// (6)
__proto__
delete Dog.prototype.name; var dog = new Dog("so16");
(6)
Dog anim
(4) (5)
prototype bark2 prototype
Animal.call(this); __proto__ alert("BowWow");

Animal prototype
prototype bark prototype
this.name = name; __proto__ alert(this.name);


thank you


Basic Mechanism of OOPL

More Related Content

What's hot

Similar to Basic Mechanism of OOPL

More from kwatch

Recently uploaded

Basic Mechanism of OOPL