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

Recommended

Recommended

More Related Content

What's hot

What's hot (19)

Similar to Basic Mechanism of OOPL

Similar to Basic Mechanism of OOPL (20)

More from kwatch

More from kwatch (20)

Recently uploaded

Recently uploaded (20)

Basic Mechanism of OOPL