Understanding the PHP Object Model

Welcome! Understanding the PHP Object Model Sebastian Bergmann http://sebastian-bergmann.de/ May 28 th 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

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)

__isset($attributeName)

Storing Data in Objects <?php class Employee { public $id ; public $name ; }

Attributes publicly accessible

Attributes are also called fields or slots sometimes

No enforcement of value types

Public Attributes

Storing Data in Objects <?php class Employee { protected $id ; protected $name ; public function getId () { return $this -> id ; } public function setId ( $id ) { if ( is_int ( $id )) { $this -> id = $id ; } else { throw new InvalidArgumentException ; } } // ... }

Attributes not directly accessible

Enforcement of value types in setter methods

Protected Attributes and Accessor Methods

Storing Data in Objects <?php class Employee { protected $id ; protected $name ; public function getId () { return $this -> id ; } public function setId ( $id ) { if ( is_int ( $id )) { $this -> id = $id ; } else { // ... } } // ... }

But attributes might still be (unintentionally) accessed directly from “within”

No syntactic relationship between the attribute and the methods that manage it

No syntactic relationship between the attribute and the methods that manage it

These methods have to be called explicitly by the accessing context

Storing Data in Objects Properties

Construct in languages such as C# or Delphi

Just like an attribute, but access is automatically translated into method calls

Use Cases

Type Checking

Bounds Checking

Read-Only Attributes

Persistence

...

Storing Data in Objects Properties

Construct in languages such as C# or Delphi

Just like an attribute, but access is automatically translated into method calls

Use Cases

Type Checking

Bounds Checking

Read-Only Attributes

Persistence

...

Can be implemented in PHP using the __get() , __set() , and __isset() interceptors

This is an idiom used in the eZ Components

Interlude eZ Components

Provide a solid platform for PHP application development

Clean and simple API

Excellent documentation

Keep backward compatibility for longer periods of time

Stable and few regressions

Clean IP, Open Source friendly

http://ezcomponents.org/

Properties The eZ Components Way <?php class Employee { protected $properties = array( 'id' => NULL , 'name' => NULL ); public function __get ( $name ) { switch ( $name ) { case 'id' : case 'name' : { return $this -> properties [ $name ]; } } throw new ezcBasePropertyNotFoundException ( $name ); } // ... }

Properties The eZ Components Way <?php class Employee { public function __set ( $name , $value ) { switch ( $name ) { case 'id' : { if ( is_int ( $value )) { $this -> properties [ $name ] = $value ; } } break; // ... } throw new ezcBasePropertyNotFoundException ( $name ); } // ... }

Properties The eZ Components Way <?php class Employee { // ... public function __isset ( $name ) { switch ( $name ) { case 'id' : case 'name' : { return TRUE ; } } return FALSE ; } }

Type-Safe Properties <?php class Employee { /** * @var integer */ protected $id ; /** * @var string */ protected $name ; }

By now we are used to annotate attribute declarations with type information

This metadata is used, for instance, by PHPDocumentor to generate API documentation

Annotations

But it is also usefull when we want to automatically generate SQL queries or WSDL from an object

Annotations

But it is also usefull when we want to automatically generate SQL queries or WSDL from an object

PHP allows read access to these docblocks at runtime through its Reflection API

So let us use this metadata for reusable __get() and __set() implementations

Annotations

Interlude <?php class Employee { /** * @var integer */ protected $id; /** * @var string */ protected $name; } $class = new ReflectionClass ( 'Employee' ); $attributes = $class -> getProperties (); foreach ( $attributes as $attribute ) { $docComment = $attribute -> getDocComment (); if ( preg_match ( '/@var[s]+([.w]+)/' , $docComment , $matches )) { var_dump ( $matches [ 1 ]); } } Annotations and the Reflection API

Type-Safe Properties <?php abstract class TypeSafeObject { protected $annotationsParsed = FALSE ; protected $properties = array(); protected function parseAnnotations () { if (! $this -> annotationsParsed ) { $class = new ReflectionClass ( $this ); $attributes = $class -> getProperties (); foreach ( $attributes as $attribute ) { $docComment = $attribute -> getDocComment (); if ( preg_match ( '/@var[s]+([.w]+)/' , $docComment , $matches )) { $this -> properties [ $attribute -> getName ()] = array( 'type' => $matches [ 1 ], 'value' => NULL ); } } $this -> annotationsParsed = TRUE ; } } // ... The TypeSafeObject Class

Type-Safe Properties public function __get ( $name ) { $this -> parseAnnotations (); if ( isset ( $this -> properties [ $name ])) { return $this-> properties [ $name ][ 'value' ]; } else { // ... } } The TypeSafeObject Class

Type-Safe Properties public function __get($name) { $this->parseAnnotations(); if (isset($this->properties[$name])) { return $this->properties[$name]['value']; } else { // ... } } public function __set ( $name , $value ) { $this -> parseAnnotations (); if ( isset ( $this -> properties [ $name ]) ) { if ( gettype ( $value ) == $this -> properties [ $name ][ 'type' ]) { $this -> properties [ $name ][ 'value' ] = $value ; } else { // ... } } else { // ... } } // ... The TypeSafeObject Class

Type-Safe Properties public function __isset ( $name ) { $this -> parseAnnotations (); return isset ( $this -> properties [ $name ]); } } The TypeSafeObject Class

Type-Safe Properties <?php class Employee extends TypeSafeObject { /** * @var integer */ protected $id ; /** * @var string */ protected $name ; } Using the TypeSafeObject Class

Type-Safe Properties <?php class Employee extends TypeSafeObject { /** * @var integer */ protected $id; /** * @var string */ protected $name; } $e = new Employee ; var_dump ( $e -> id ); NULL Using the TypeSafeObject Class

Type-Safe Properties <?php class Employee extends TypeSafeObject { /** * @var integer */ protected $id; /** * @var string */ protected $name; } $e = new Employee; $e -> id = '123' ; var_dump ( $e -> id ); NULL Using the TypeSafeObject Class

Type-Safe Properties <?php class Employee extends TypeSafeObject { /** * @var integer */ protected $id; /** * @var string */ protected $name; } $e = new Employee; $e -> id = 123 ; var_dump ( $e -> id ); int(123) Using the TypeSafeObject Class

Type-Safe Properties <?php abstract class TypeSafeObject { // ... } class Employee extends TypeSafeObject { /** * @var integer */ protected $id ; /** * @var string */ protected $name ; } Problems with the TypeSafeObject Class

Conceptual problem

Employee is a TypeSafeObject

Type-Safe Properties <?php abstract class TypeSafeObject { // ... } class Person extends TypeSafeObject { // ... } class Employee extends Person { /** * @var integer */ protected $id; /** * @var string */ protected $name; } Problems with the TypeSafeObject Class

Conceptual problem

This usually does not fit into our model

Type-Safe Properties <?php abstract class TypeSafeObject { // ... } class Person extends TypeSafeObject { // ... } class Employee extends Person { /** * @var integer */ protected $id; /** * @var string */ protected $name; } Problems with the TypeSafeObject Class

Conceptual problem

PHP 5.3 supports

Single Implementation Inheritance

Multiple Interface Inheritance

Type-Safe Properties <?php trait TypeSafeObject { // ... } class Person { use TypeSafeObject ; // ... } class Employee extends Person { /** * @var integer */ protected $id; /** * @var string */ protected $name; } Traits to the rescue!

Conceptual problem

PHP 5.3 supports

Single Implementation Inheritance

Multiple Interface Inheritance

Future versions of PHP will support Traits

Safe variant of multiple implementation inheritance

A class can extend a single class

A class can use multiple traits

Reuse sets of methods freely in several independent classes living in different class hierarchies

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.