1. 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.

2. 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, ...
copyright© 2009 kuwata-lab.com all right reserved.

3. Agenda
✤ Part 1. Basics about OOPL Mechanism
✤ Part 2. More about OOPL Mechanism
✤ Part 3. Case Study
copyright© 2009 kuwata-lab.com all right reserved.

4. Part 1.
Basics about OOPL Mechanism
copyright© 2009 kuwata-lab.com all right reserved.

5. 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 .....
}
copyright© 2009 kuwata-lab.com all right reserved.

6. 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++)
copyright© 2009 kuwata-lab.com all right reserved.

7. 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

8. 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;
}
copyright© 2009 kuwata-lab.com all right reserved.

9. 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);
copyright© 2009 kuwata-lab.com all right reserved.

10. 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)
copyright© 2009 kuwata-lab.com all right reserved.

11. 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 .....
}
copyright© 2009 kuwata-lab.com all right reserved.

12. 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
copyright© 2009 kuwata-lab.com all right reserved.

13. Part 2.
More about OOPL Mechanism
copyright© 2009 kuwata-lab.com all right reserved.

14. 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
copyright© 2009 kuwata-lab.com all right reserved.

15. Method Overload
✤ One method name can have different method
signature
Class obj Method Table
hello(IC)
hello(Ljava.lang.String;)
copyright© 2009 kuwata-lab.com all right reserved.

16. Method Override
✤ Child class can define methods which has same
method signature as method in parent class
Parent Class Method Table
hello(IC)
hello(Ljava.lang.String;)
Child Class Method Table
hello(Ljava.lang.String;)
:
copyright© 2009 kuwata-lab.com all right reserved.

17. 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
:
copyright© 2009 kuwata-lab.com all right reserved.

18. 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) {
.....
: :
}
: :
copyright© 2009 kuwata-lab.com all right reserved.

19. 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) {
.....
: :
}
: :
copyright© 2009 kuwata-lab.com all right reserved.

20. "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"
copyright© 2009 kuwata-lab.com all right reserved.

21. "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"
copyright© 2009 kuwata-lab.com all right reserved.

22. 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
copyright© 2009 kuwata-lab.com all right reserved.

23. 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
copyright© 2009 kuwata-lab.com all right reserved.

24. Part 3.
Case Study
copyright© 2009 kuwata-lab.com all right reserved.

25. Case Study: Ruby
from ruby.h: from ruby.h:
struct RBasic { struct RClass {
unsigned long flags; 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
copyright© 2009 kuwata-lab.com all right reserved.

26. 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) = @_; first argument of
$this->{x} = $x; instance method
$this->{y} = $y;
} copyright© 2009 kuwata-lab.com all right reserved.

27. Case Study: Python
class Point(object):
def __init__(self, x=0, y=0):
self.x = x Instance object is the
self.y = y first 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.
copyright© 2009 kuwata-lab.com all right reserved.

28. 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) { ... }
copyright© 2009 kuwata-lab.com all right reserved.

29. 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);
copyright© 2009 kuwata-lab.com all right reserved.

30. 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);
copyright© 2009 kuwata-lab.com all right reserved.

31. thank you
copyright© 2009 kuwata-lab.com all right reserved.