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.