Object Oriented

PHP
An Introduction

Matthew Weier O'Phinney

btv php
Who's this guy, then?

PHP Developer since

2000; full-time since
2003
PHP Developer for
Zend Technologies
since 2005
Zend Framework
contributor since
January 2006
Zend Framework
project lead since April
2009
I live and breathe OOP
daily
Who Are You?

How many of you have used

OOP before?
How many of you use OOP
regularly?
If you're not using OOP, why are
you interested?
What is OOP?
Object Oriented Programming

Models software concepts as

discrete entities, containing
attributes and capable of
performing actions that may
optionally use those attributes.
Start with what you know
Constants and Variables

define(FOO, 'foo');
define(BAR, 'bar');
$value = 'bar';

switch ($value) {
case FOO:
// do something;
break;
case BAR:
// do something else
break;
}
Associative Arrays

$person = array(
'last_name' => "Weier O'Phinney",
'first_name' => "Matthew",
'occupation' => 'PHP Developer',
'gender' => 'Male',
'email' => 'matthew@example,com',
);
Functions

function mail($to, $subject, $body)

{
// ... do some stuff
// optionally return something:
return true;
}
Objects group related subjects
Start with a class declaration

class Person
{
}
Define some common class
member variables

class Person
{
public $firstName;
public $lastName;
public $occupation;
public $gender;
public $email;
}
Some types of class members

Variables
Declared using a visibility
operator and normal variable
naming
Constants
Declared with the const
keyword, and no quotes
Methods
Declared with the function
keyword
define methods, which are
functions inside a class

class Person
{
// ... attributes ...
public function boast()
{
return sprintf('%s %s is a %s',
$this->firstName,
$this->lastName,
$this->occupation
);
}
}
Instance variables!
Use your objects!

$matthew = new Person();

$matthew->firstName = 'Matthew';
$matthew->lastName = "Weier O'Phinney";
$matthew->email = 'matthew@example.com';
$matthew->gender = 'male';
$matthew->occupation = 'PHP Developer';

echo $matthew->boast();
// Matthew Weier O'Phinney is a PHP Developer
Why bother?
It's good programming

Scope and encapsulation

Re-use
(both re-using a class by
instantiating many objects, and
class extension)
Type enforcement
Testability and maintenance
Some words on scope

Methods have access to:
Whatever is passed to them
Any class member variables,
constants, or methods (with
respect to visibility)
Use $this-> within a class to
access member variables and
methods (unless statically
declared); use -> when
consuming an instance
Use self:: to access member
constants
What is this visibility stuff?

Determines scope in which a class

member may be accessed.
Public: can be accessed via
instances, anywhere within the
class definition, and by any
extending class.
Protected: can be accessed
within the class definition, and
by extending classes.
Private: may only be accessed
and modified within the defining
class.
Extension?

Use the extends keyword:

class Matthew
extends Person
Extends
keyword!
 Extension: override properties

class Matthew extends Person

{
public $firstName = 'Matthew';
public $lastName = "Weier O'Phinney";
public $occupation = 'PHP Developer';
public $email = 'matthew@example.com';
public $gender = 'male';
}
 Extension: override methods

class Matthew extends Person

{
public function boast()
{
// get parent value from method
$boast = parent::boast();
$boast .= ', and wrote this presentation';
return $boast;
}
}

Access the original method!

Extension: use the new class

Note:
using Matthew,
not Person!
$matthew = new Matthew();
echo $matthew->boast();
// Matthew Weier O'Phinney is a PHP Developer,
// and wrote this presentation

boast() now says

something new!
Abstraction

A formal way of defining

extension points
Two types:
Interfaces
Abstract Classes
Interfaces

Defines a public contract for

classes that implement it
Ensures consuming classes will
always have specific methods
available
A sample interface

Interface
keyword!

interface Animal
{
public function makeNoise();
public function eat($food);
}
Interfaces may extend
other interfaces

interface Collection
extends Countable,
IteratorAggregate
{
}
Collection now
inherits methods
from Countable and
IteratorAggregate
 Implementing an interface means
defining the interfaces methods

class Family
extends Order
implements Collection
{
// defined by Countable
public function count() {}

// defined by IteratorAggregate
public function getIterator() {}
}

implements keyword;
this object follows that
contract
Abstract Classes

Sometimes it's useful to create a

base set of functionality.
At the same time, you may want
to leave certain details up to
implementing classes.
Sample Abstract Class
abstract
keyword;
abstract class Person
{ extending class
public $firstName; must implement
public $lastName;
public $email;
public $occupation;
public $gender;

public function speak() {

/* implementation in here */
}
// let extension define this, though:
abstract public function eat($food);
}
Abstract classes can also
implement interfaces

abstract class Family

extends Order
implements Collection
{
}
Magic methods

Always prefixed by __ (double

underscore)
Some tie into various object
states (initialization, destruction,
cloning)
Some allow "overloading" the
functionality of the object (set or
get "virtual" members; call
"virtual" methods; etc.)
Object initialization

Magic method:
constructor

public function __construct(

$firstName, $lastName
) {
$this->firstName = $firstName;
$this->lastName = $lastName;
}
And on the subjects of
scope and inheritance...

STATIC members:
Class members that do not
require an object instance in
order to operate.
Global state (i.e., does not
vary between instances); use
rarely and wisely.
Uses the "Paamayim
Nekudotayim" operator (`::`)
for scope resolution
Static example
The type is small
because I don't want
class Registry you to use statics. :)
{
protected static $values = array();

public static function set($name, $value)

{
static::$values[$name] = $value;
}

public static function get($name)

{
if (isset(static::$values[$name])) {
return static::$values[$name];
}
return null;
}
}
Registry::set('foo', 'bar');
echo Registry::get('foo'); // 'bar'
Type validation

PHP allows you to typehint on

any class, abstract class, or
interface name.
if (!$matthew instanceof Person) {
echo "Imposter!";
}
Parting remarks
Keep your objects discrete and
concise

All members should be related

to a discrete subject
Methods should not do too
much
Too many members often
means you're mixing concerns,
and should separate into more
classes
Statics: don't do them

Static functionality is appealing

and seductive, but that way
leads to the Dark Side
Magic methods

Learn the magic methods, but

don't lean to heavily on them
Except in the case of
__construct(), which is
almost always a good idea.
Learn the SPL

Some SPL interfaces allow

array-like access to objects,
including iteration, array access
to properties, etc.
Objects like ArrayObject,
SplStack, and others can be
huge time savers.
Solutions based off of SPL will
almost always be faster than
userland code.
Use OOP

but don't forget your

procedural roots;
if a function will do, use it.
Resources

http://thinkvitamin.com/author/lornajanemitchell/
http://php.net/oop
http://php.net/spl