Understanding the PHP Object Model

Welcome! Understanding the PHP Object Model Sebastian Bergmann http://sebastian-bergmann.de/ May 22 nd 2008

Who I am
Sebastian Bergmann
Involved in the PHP Project since 2000
Developer of PHPUnit
Author, Consultant, Coach, Trainer

Outline
Before we can “dive into” the object model of PHP, we need to understand the basic concepts of object-orientation

Outline
Then we can look at how PHP implements these concepts

Outline
Then we can look at how PHP implements these concepts
Finally, we can look at what PHP supports in addition to the basic concepts of object-orientation

Introduction
Answer #1 (by Timothy A. Budd)
What is Object-Orientation?

Introduction
Everything is an object

Introduction
Objects communicate by sending messages

Introduction
Objects have private state

Introduction
Every object is an instance of one class

Introduction
Every object is an instance of one class
A class can inherit from another class

Introduction
Answer #2 (by Benjamin C. Pierce)
Dynamic Dispatch
Encapsulation
Interface Inheritance
Implementation Inheritance
Open Recursion

Introduction
Dynamic Dispatch
Process of mapping a message to code at runtime
Encapsulation
Open Recursion

Introduction
Dynamic Dispatch
Encapsulation or Information Hiding
Hiding of design decisions that are most likely to change
Open Recursion

Introduction
Dynamic Dispatch
Encapsulation
Classes share a set of messages they understand
Open Recursion

Introduction
Dynamic Dispatch
Encapsulation
Classes share code
Open Recursion

Introduction
Dynamic Dispatch
Encapsulation
Open Recursion
A method can invoke another method on the same object via a special, late-bound variable

OOP Syntax and Semantics in PHP <?php class Tomato { } Class Declaration

OOP Syntax and Semantics in PHP <?php require_once 'Tomato.php' ; $tomato = new Tomato ; Object Instantiation

OOP Syntax and Semantics in PHP <?php $classes = array( 'Tomato' => 'Tomato.php' ); function __ autoload ( $className ) { if ( isset ( $classes [ $className ])) { require_once $classes [ $className ]; } } $tomato = new Tomato; Class Loading with __autoload()

OOP Syntax and Semantics in PHP <?php class Tomato { protected $utilized = FALSE ; } Attributes: Object-Scope Variables

OOP Syntax and Semantics in PHP <?php class Tomato { protected $utilized = FALSE; public function utilize () { $this -> utilized = TRUE ; } } Methods: Object-Scope Functions

<?php class Tomato { protected $utilized = FALSE; public function utilize() { $this ->utilized = TRUE; } } Late-bound variable that references the object that the method in which it is used has been called on OOP Syntax and Semantics in PHP Methods: Object-Scope Functions

OOP Syntax and Semantics in PHP <?php class Example { private $a = 'Can only be accessed by objects of the Example class' ; protected $b = 'Can only be accessed by objects of the Example class or objects of classes that extend the Example class' ; public $c = 'Can be accessed from every scope' ; } Visibility of Attributes and Methods

OOP Syntax and Semantics in PHP <?php $tomato = new Tomato; $tomato -> utilize (); Method Invokation

OOP Syntax and Semantics in PHP <?php class Foo { public $bar = 'baz' ; } $foo = new Foo ; print $foo -> bar ; baz Visibility of Attributes and Methods

OOP Syntax and Semantics in PHP <?php class Foo { private $bar = 'baz' ; } $foo = new Foo; print $foo->bar; Fatal error: Cannot access private property Foo::$bar in /tmp/test.php on line 11 Visibility of Attributes and Methods

OOP Syntax and Semantics in PHP <?php class Foo { private $bar = 'baz'; public function doSomething(Foo $foo) { print $foo->bar; } } $foo = new Foo; $foo -> doSomething (new Foo ); baz Visibility of Attributes and Methods

OOP Syntax and Semantics in PHP <?php class Tomato { protected $utilized = FALSE; public function utilize () { if (! $this -> utilized) { $this -> utilized = TRUE ; } else { throw new Exception ( 'Already utilized.' ); } } } Raising Errors

OOP Syntax and Semantics in PHP <?php $tomato = new Tomato; try { $tomato->utilize(); } catch ( Exception $e ) { print $e -> getMessage (); } Handling Errors

OOP Syntax and Semantics in PHP <?php class Tomato { protected $utilized; public function __construct () { $this -> utilized = FALSE ; } } Special Methods: Constructor

OOP Syntax and Semantics in PHP <?php class Tomato { protected $utilized; public function __construct() { $this->utilized = FALSE; } public function __destruct () { if (! $this -> utilized ) { print "Tomato spoiled. " ; } } } Special Methods: Destructor

OOP Syntax and Semantics in PHP <?php $a = new StdClass ; // Create new object $b = $a ; // Reference object from another // another variable var_dump ( $a == $b ); // bool(true) var_dump ( $a === $b ); // bool(true) Object Equality and Object Identity

OOP Syntax and Semantics in PHP <?php $a = new StdClass; // Create new object $b = $a; // Reference object from another // another variable var_dump($a == $b); // bool(true) var_dump($a === $b); // bool(true) $a -> foo = 'bar' ; // Set an attribute of the // object through one variable var_dump ( $a -> foo ); // string(3) "bar" var_dump ( $b -> foo ); // string(3) "bar" Object Equality and Object Identity

OOP Syntax and Semantics in PHP <?php $a = new StdClass; // Create new object $b = $a; // Reference object from another // another variable var_dump($a == $b); // bool(true) var_dump($a === $b); // bool(true) $b = clone $a ; // Create a copy of the object // referenced by $a var_dump ( $a == $b ); // bool(true) var_dump ( $a === $b ); // bool(false) Object Equality and Object Identity

OOP Syntax and Semantics in PHP <?php $a = new StdClass; // Create new object $b = $a; // Reference object from another // another variable var_dump($a == $b); // bool(true) var_dump($a === $b); // bool(true) $b = clone $a; // Create a copy of the object // referenced by $a var_dump($a == $b); // bool(true) var_dump($a === $b); // bool(false) $a -> foo = 'bar' ; var_dump ( $a == $b ); // bool(false) Object Equality and Object Identity

OOP Syntax and Semantics in PHP <?php class Example { public function __ construct () { print "Example:: __ construct() called. " ; } public function __ clone () { print "Example:: __ clone() called. " ; } } $a = new Example ; $b = clone $a ; ?> Example:: __ construct() called. Example:: __ clone() called. Special Methods: Clone Constructor

Circular References <?php $root = new Node ;

Circular References <?php $root = new Node; $root -> addChild (new Node );

Circular References <?php $root = new Node; $root->addChild(new Node); unset( $root ); PHP 5.2
PHP 5.3 introduces a Garbage Collector that can deal with circular references

Inheritance
Single Inheritance
A class can inherit interface and implementation from a single parent class

Inheritance
Single Inheritance
Interfaces
A class can implement multiple interfaces

Inheritance
Single Inheritance
Interfaces
A class can implement multiple interfaces
Multiple Inheritance
A class can inherit interface and implementation from multiple parent classes

Inheritance <?php class Tomato {}

Inheritance <?php class Vegetable {} class Tomato extends Vegetable {}
Vegetable
Tomato
is a type of Vegetable

Inheritance <?php abstract class Vegetable {} class Tomato extends Vegetable {}
Vegetable
is something abstract
Tomato
is something concrete

Inheritance <?php abstract class Item {} abstract class Food extends Item {} abstract class Vegetable extends Food {} class Tomato extends Vegetable {}
Item
Food
is a type of Item
Vegetable
is a type of Food
Tomato

Inheritance <?php interface Edible {} interface Rollable {} interface Sellable {} interface Squeezable {} abstract class Item implements Sellable {} abstract class Food extends Item implements Edible {} abstract class Vegetable extends Food {} class Tomato extends Vegetable implements Rollable , Squeezable {}
Item
is something that can be sold
Food
is a type of Item
Is something that can be eaten
Vegetable
is a type of Food
Tomato
is something that can be squeezed
is something that can be rolled

Inheritance <?php interface Edible {} interface Rollable {} interface Sellable {} interface Squeezable {} abstract class Item implements Sellable {} abstract class Food extends Item implements Edible {} abstract class Fruit extends Food {} abstract class Vegetable extends Food {} class Banana extends Fruit implements Squeezable {} class Tomato extends Vegetable implements Rollable, Squeezable {}
Item
is something that can be sold
Food
is a type of Item
Is something that can be eaten
Fruit
is a type of Food
Banana
is a type of Fruit
is something that can be squeezed

Inheritance <?php interface Rollable { public function roll (); } abstract class Item {} abstract class Food extends Item {} abstract class Vegetable extends Food {} class Tomato extends Vegetable implements Rollable { public function roll () { // do something } }

Inheritance <?php interface Rollable { public function roll(); } interface Sqeezable { public function sqeeze (); } abstract class Item {} abstract class Food extends Item {} abstract class Vegetable extends Food {} class Tomato extends Vegetable implements Rollable, Sqeezable { public function roll() { // do something; } public function squeeze () { $this -> utilize (); return 'tomato juice' ; } }

Inheritance <?php class Juicer { public function squeeze ( Squeezable $squeezable ) { $juice = $squeezable -> squeeze (); } }

Inheritance <?php class Juicer { public function squeeze(Squeezable $squeezable) { $juice = $squeezable->squeeze(); } } class Roller { public function roll ( Rollable $rollable ) { $rollable -> roll (); } }

Object Context <?php class Food extends Item { protected $utilized ; public function __construct () { printf( "%s harvested " , get_class ( $this )); $this -> utilized = FALSE ; } public function __destruct () { if (! $this -> utilized ) { printf( "%s spoiled " , get_class ( $this )); } } public function utilize () { $this -> utilized = TRUE ; } }

Class Context <?php class Food extends Item { protected $utilized; protected static $statistics = array(); public function __construct() { printf("%s harvested ", get_class($this)); $this->utilized = FALSE; self:: $statistics [ get_class ( $this )][ 'harvested' ]++; } public function __destruct() { if (!$this->utilized) { printf("%s spoiled ", get_class($this)); self:: $statistics [ get_class ( $this )][ 'spoiled' ]++; } } public function utilize() { $this->utilized = TRUE; self:: $statistics [ get_class ( $this )][ 'utilized' ]++; } } Class Attributes

Class Context <?php class Food extends Item { // ... public static function utilizationRate ( $food ) { return (self:: $statistics [ $food ][ 'utilized' ] / self:: $statistics [ $food ][ 'harvested' ]) * 100 . '%' ; } } Class Methods

Class Context <?php class Food extends Item { // ... public static function utilizationRate($food) { return (self::$statistics[$food]['utilized'] / self::$statistics[$food]['harvested']) * 100 . '%'; } } $tomato = new Tomato ; print Food :: utilizationRate ( 'Tomato' ); Tomato harvested 0% Tomato spoiled Class Methods

Class Context <?php class Food extends Item { // ... public static function utilizationRate($food) { return (self::$statistics[$food]['utilized'] / self::$statistics[$food]['harvested']) * 100 . '%'; } } $tomato = new Tomato; print Food::utilizationRate('Tomato'); $juicer = new Juicer ; $juicer -> squeeze (new Tomato ); print Food :: utilizationRate ( 'Tomato' ); Tomato harvested 0% Tomato harvested Tomato utilized 50% Tomato spoiled Class Methods

Class Context <?php class Base { public static function a () { print "Base::a() called " ; self:: b (); } public static function b () { print "Base::b() called " ; } } Base :: a (); Base::a() called Base::b() called Early Static Binding

Class Context <?php class Base { public static function a() { print "Base::a() called "; self::b(); } public static function b() { print "Base::b() called "; } } class Child extends Base { public static function b () { print "Child::b() called " ; } } Child :: a (); Base::a() called Base::b() called Early Static Binding

Class Context <?php class Base { public static function a() { print "Base::a() called "; Base :: b (); } public static function b() { print "Base::b() called "; } } class Child extends Base { public static function b() { print "Child::b() called "; } } Child::a(); Base::a() called Base::b() called Early Static Binding
self is replaced with the name of the class it is used in at compile-time

Class Context <?php class Base { public static function a() { print "Base::a() called "; static :: b (); } public static function b() { print "Base::b() called "; } } class Child extends Base { public static function b() { print "Child::b() called "; } } Child :: a (); Base::a() called Child::b() called Late Static Binding
self is replaced with the name of the class it is used in at compile-time
static is late-bound and evaluated at runtime

Class Context <?php class Example { const SOME_CONSTANT = 'some value' ; public function aMethod ( $arg = self:: SOME_CONSTANT ) { } } print Example :: SOME_CONSTANT ; some value Class Constants

Interceptors
__call($methodName, $arguments)
__callStatic($methodName, $arguments)
__get($attributeName)
__set($attributeName, $value)
Interested in usage examples of __get() and __set() , as well as examples for the Reflection API, Traits, and other cool stuff? Come to my session tomorrow! Type-Safe Objects in PHP 11:15 – 12:15

The End
Thank you for your interest!
These slides will be available shortly on http://sebastian-bergmann.de/talks/.

License
This presentation material is published under the Attribution-Share Alike 3.0 Unported license.
You are free:
to Share – to copy, distribute and transmit the work.
to Remix – to adapt the work.
Under the following conditions:
Attribution. You must attribute the work in the manner specified by the author or licensor (but not in any way that suggests that they endorse you or your use of the work).
Share Alike. If you alter, transform, or build upon this work, you may distribute the resulting work only under the same, similar or a compatible license.
For any reuse or distribution, you must make clear to others the license terms of this work.
Any of the above conditions can be waived if you get permission from the copyright holder.
Nothing in this license impairs or restricts the author's moral rights.

http://woork.blogspot.com	3422
http://www.techgig.com	581
http://www.dreamcss.com	561
http://sebastian-bergmann.de	426
http://woork.blogspot.in	178
http://skyhighsoftware.com	177
http://cachi.temiga.org	147
http://www.slideshare.net	129
http://lukebrincat.wordpress.com	121
http://www.getincss.ru	119
http://blog.pablo-morales.com	106
http://hpfloresj.blogspot.com	90
http://www.phpinternals.com	84
http://dreamcss.blogspot.com	83
http://acidminds.com	81
http://www.phphatesme.com	64
http://hwcss.blogspot.com	58
http://blog.reflectiv.net	57
http://www.neatstudio.com	55
http://zendhispano.blogspot.com	43
http://monw3c.blogbus.com	43
http://www.blogdopedro.net	33
http://shorttags.wordpress.com	32
http://183.181.52.118	32
http://www.planet-php.net	28
http://translate.googleusercontent.com	21
http://nitoenti.blogspot.com	21
http://min2liz.net	20
http://www.reflectiv.net	19
http://livebuzz.com.br	18
http://woork.blogspot.de	15
http://www.neatcn.com	14
http://woork.blogspot.com.br	13
http://woork.blogspot.it	12
http://10.150.200.57	12
http://www.planet-php.org	11
http://asklife.info	11
http://woork.blogspot.co.uk	11
http://localhost	11
http://woork.blogspot.ca	10
http://static.slideshare.net	7
http://woork.blogspot.pt	7
http://woork.blogspot.fr	7
http://onwebdev.blogspot.com	6
http://woork.blogspot.com.es	6
http://unixbsd.blogspot.com	6
http://adsensetutorialz.blogspot.in	5
http://lj-toys.com	5
http://labs.friendsinteraction.com	5
http://edu.liulizhi.info	5
http://blog.theemann.dk	4

Understanding the PHP Object Model

by Sebastian Bergmann on May 23, 2008

Accessibility

Categories

Tags

Upload Details

Usage Rights

119 Embeds 7,144

Statistics

Understanding the PHP Object Model — Presentation Transcript