Intro to OOP and new features in PHP 5.3

OOP and PHP 5.3


South Florida PHP Users Group

Adam Culp
http://www.Geekyboy.com

In this presentation we will talk about OOP, and discuss
the object model progression in PHP from version 4
through the newest 5.3.
I apologize in advance, but this will not be in great detail
though I hope it is enough to help everyone in some
way.

Procedural? Really?

• PHP was started as a procedural <?php
function vehicle($wheels, $color, $hp) {
tool to perform quick tasks. // build a car using info provided
Large adoption brought more $car = array(
users who wanted OOP, so here ‘wheels’ => $wheels,
‘color’ => $color,
we are. ‘hp’ => $hp);
– Everything went fairly sequential return $car;
– Took a fair amount of labor within }

code to change values afterward $car = vehicle(4, ‘red’, 240);
– Procedural does make sense for // now continue with code that uses $car
simple tasks, such as CRON jobs to If ($car[‘color’] == ‘red’) {
perform quick tasks. echo ‘Your car is red’;
}

?>

Output:
Your car is red

Possible usage:
Here is the car: <?php print_r($car); ?>

OOP the basics

• PHP 4 brought the introduction <?php
Interface mobility {
function setColor($color);
of oop to PHP. }
function setHorsepower($hp);

– Application builds an object class Vehicle implements mobility {
– Helps with DRY (Don’t repeat public $color;
public $horsepower;
yourself) function setColor($color) {
– Simplifies structure, code still can }
$this->color = $color;

be sequential but is more ‘modular’ function setHorsepower($hp) {
– Helps keep code more readable }
$this->horsepower = $hp;

}
– Object can be manipulated easier
prior to use of the object Class Car extends Vehicle {
public $wheel;

– We instantiate the class by creating function addWheel($n) {

a “new” object, then manipulate the }
$this->wheel += $n;

object by calling the different }

“methods” within the class. $myCar = new Car();
$myCar->setColor(‘red’);
$myCar->setHorsepower(250);
$myCar->addWheel(3);
$myCar->addWheel(1);

print_r($myCar);
?>

Output:
Car Object([wheel]=>4[color]=>red[horsepower]=>250)

PHP 4 revisit

• PHP 4 had a very basic OOP <?php
class Reference {
presence, and looked something var $reference;
like this ->
// acted as constructor
– Variables need to be defined as function Reference() {
‘var’. $this->reference = ‘dictionary’;
– Constructors carried the same name }
as the Class.
function getReference() {
• Note: the constructor always runs return $this->reference;
“automagically” when the class is }
instantiated }
– No visibility
$rt = new Reference();
– No abstraction $reference = $rt->getReference;
– Very simple and easy to use, but echo ‘reference:’ . $reference;
lacked many features of other OOP ?>
languages at the time.
Output:
reference: dictionary

PHP 5.0 brought changes

• With the rollout of PHP 5.0 there were many <?php
class Reference {
changes. const DEFAULT_LANG = ‘eng’;
– Protected data with Visibility private $reference;
• Public (default) – accessed and changed private $lang;

globally public function __construct(Language $lang) {
if($lang ) {
• Protected – access and changed by $this->lang = $lang->esp;
direct descendants } else {
$this->lang = DEFAULT_LANG;
• Private – access and changed within }
class only $this->reference = ‘dictionary’;
}
– Type Hinting – notice how we specify that an
public function getReference() {
object of Language is passed to the return $this->reference;
constructor. This means we must create an }
object using the Language class first.
private function setPrivateReference() {
– Variables no longer need the ‘var’ keyword $this->reference = ‘my_dictionary’;
}
– Constructor now defined using __construct }
call
class Language {
– CONSTANT values may now be assigned public $esp = ‘Spanish’;
per-class, cannot be a variable or property or }

mathematical operation or function call. $lang = new Language();
$rt = new Reference($lang);
$reference = $rt->getReference;
echo ‘reference:’ . $reference;
?>

Output:
Reference: Spanish

PHP 5.0 Abstraction

• Abstraction <?php
abstract class Reference {
– Abstraction, if a class contains any abstract public $reference;

methods the class must also be abstract. abstract public function read();
– Abstracted methods must be defined by the public function __construct() {
child class. $this->reference = ‘dictionary’;
}
– Visibility in the method of the child class
must be the same, or less, restricted. final public function getReference() {
return $this->reference;
– “final” keyword prevents child classes from }
overriding a method
protected function setProtectedReference($myReference) {
– “clone” creates a copy of an object rather $this->reference = $myReference;
}
than continuing to use the same object. }

class Letter extends Reference {
public function read($personal) {
$myDictionary = $personal;

parent::setProtectedReference($myDictionary);

}
}

$rt = new Letter();
$reference = $rt->read(‘my english dictionary’);
$rt2 = clone $rt;

?>

Output:
reference: my english dictionary

PHP 5.0 Interfaces

• Interface <?php
interface rTemplate
– Interface, specifies which methods a {
public function getReference();
class must implement. public function setProtectedReference();
}
– All methods in interface must be public.
– Multiple interfaces can be implemented class Reference implements rTemplate {
public $reference;
by using comma separation
public function __construct() {
– Interface may contain a CONSTANT, $this->reference = ‘dictionary’;
but may not be overridden by }
implementing class public function getReference() {
}

protected function setProtectedReference($myReference) {
$this->reference = $myReference;
}
}

$rt = new Letter();
$reference = $rt->getReference();

?>

Output:
reference: dictionary

PHP 5.0 Exceptions

• <?php
Additional features with PHP 5. function inverse($x) {
– Exceptions – throwing an exception if (!$x) {
throw new Exception(‘Division by zero.’);
to gracefully error out, while } else {
continuing to execute the rest of the return 1/$x;
script even after the error. }
}
• Notice how we still get ‘Hello
World’ even after an exception try {
caused by ‘Division by zero’. echo inverse(5) . “n”;
echo inverse(0) . “n”; // trigger exception
– Exceptions can then be caught for } catch (Exception $e) {
logging, etc. echo ‘Caught exception: ‘, $e->getMessage(), “n”;
}

// continue execution
echo ‘Hello World’;
?>

Output:
0.2
Caught exception: Division by zero.
Hello World

Finally, PHP 5.3 features

• Additional features with PHP 5.3
– Namespaces
– Late Static Bindings
– Jump labels (goto)
– Closures
– __callStatic() and __invoke()
– Class Constants
– Nowdoc syntax supported
– Use Heredocs to initialize static
variables and class properties
– Heredocs with double quotes
– Ternary operator shortcut
– HTTP status 200 to 399 = success
– Dynamic access to static methods
– Exception nesting
– mail() logging of sent email

Namespaces

• Namespaces <?php
declare (encoding=‘UTF-8’);
– Help create a new layer of code namespace automobile;
encapsulation. class Automobile {
• Keep properties from colliding function setType($type) {
echo __NAMESPACE__ . “n”;
between areas of your code }
• Only classes, interfaces, functions }

and constants are affected namespace automobilecar;
– Anything that does not have a class Car {
namespace is considered in the function toyota() {
echo “test driven”;
Global namespace (namespace = }
“”) }

– Namespace must be declared first $car = new Car
$car->toyota();
(except ‘declare’ statement)
// OR you can use the namespace
– Can define multiple namespaces in
$auto = new automobilecarCar;
the same file. $auto->toyota();

?>

Output:
test drive
test drive

Namespaces – cont.

• Namespaces – cont. <?php
namespace automobile;
– You can define that something be class Automobile {
used in the “Global” namespace by function setType($type) {
echo __NAMESPACE__ . “n”;
enclosing a non-labeled namespace }
in {} brackets. (Note: if you have }

multiple namespaces in the same namespace automobilecar;
file they must all use this notation.) use automobile as auto;
– Use namespaces from within other class Car {
namespaces, along with aliasing function toyota() {
echo “test driven”;
}
}

namespace {
//global code, for this to work the examples above would also
need to use bracketed syntax
}

$automobile = new autoAutomobile;
$automobile->setType(‘none’);
?>

Output:
automobile

Late Static Bindings

• Late Static Binding <?php
class Automobile {
– Stores the class name of the last private function type() {
echo “Success!n”;
“non-forwarded call”. }

public function test() {
$this->type();
static::type();
}
}

class Car extends Automobile {
// empty
}

Class Truck extends Automobile {
private function type() {
// empty
}
}

$car = new Car;
$car->test();
$truck = new Truck;
$truck->test(); //fails because there is no test() in Truck
?>

Output:
Success!
Success!
Success!
Fatal error: Call to private method Truck::type() from context
‘Automobile’ in {file} on line n

Jump Labels (goto)

• Jump Labels (goto) <?php
– Used to jump to another section in // some code here
the program.
goto a;
– Target is specified by a label echo ‘Foo’;
followed by a colon.
– Target must be within the same file // more code here
and context.
• Cannot jump out of a function or a:
method, and cannot jump into one.
– Cannot jump into any sort of loop echo ‘Bar’;
or switch structure, but may jump ?>
out.

Output:
Bar

Closures (Anonymous functions)

• Closures (Anonymous functions) <?php
class Cart {
– Allows the creation of functions protected $products = array();
const PRICE_SHIRT = 20.00;
which have no specific name. const PRICE_SCARF = 4.00;

– Most useful as the value of callback public function order() {
$this->products[‘shirt’] = 2;
parameters. $this->products[‘scarf’] = 3;
}
– Can be used as the value of a
variable. public function getTotal($tax) {
$total = 0.00;
– Can inherit variables from the $callback = function ($quantity, $product) use ($tax, &$total) {
parent scope. (Not the same as $pricePerItem =
constant(__CLASS__ . “::PRICE_” . strtoupper($product));
using global variables)
$total += ($pricePerItem * $quantity) * ($tax +1.0);
};
array_walk($this->products, $callback);

return round($total, 2);
}
}
?>

Output:
55.64

Nested Exceptions

• Nested Exceptions <?php
class MyException extends Exception {}
– Now your criteria within a “try” can
also have another “try” nested class Test {
within, thus causing two levels of public function testing() {
failure to caught for further logging. try {
try {
throw new MyException(‘foo!’);
} catch (MyException $e) {
throw $e;
}
} catch (Exception $e) {
var_dump($e->getMessage());
}
}
}

$foo = new Test;
$foo->testing();
?>

Output:
String(4) “foo!”

New magic methods

• __callStatic()
– Used during overloading. Gives No code to go with this…
warning to enforce public visibility
and non-static declaration. yet. Experiment on your
• Triggered when invoking
inaccessible methods in a static own.
context.
• __invoke()
– Called when a script tries to call an
object as a function

Nowdoc

• Nowdoc <?php
– nowdoc is similar to heredoc, but echo <<<‘EOT’
no parsing is done inside a nowdoc. My $foo->foo.
name is “$name”. I am printing some
• Ideal for code snippets or large Now, I am printing some {$foo->bar[1]}.
blocks of text without the need for This should not print a capital ‘A’: /x41
escaping. EOT;
• Best used with static content. ?>
– Uses the same <<< sequence, but
the following identifier is encosed
in single quotes.

Output:
My name is “$name”. I am printing some
$foo->foo.
Now, I am printing some {$foo->bar[1]}.
This should not print a capital ‘A’: /x41

Heredoc changes

• Heredoc <?php
// Static variables
– heredoc can now initialize static function foo() {
variables and class static $bar = <<<“LABEL”
properties/constants. Nothing in here…
– Can now be declared (optional) LABEL;
}
using double quotes,
complementing the nowdoc syntax // Class properties/constants
which uses single quotes. Class foo {
const BAR = <<<FOOBAR
Constant example
FOOBAR;

public $baz = <<<FOOBAR
Property example
FOOBAR
}

?>

Constants addition

• Constants addition <?php
– A constant may now be declared const TEST = ‘bar’;
outside a class using the ‘const’
keyword instead of ‘declare’. Function foo() {
echo ‘foo’;
}

foo();

echo TEST;

?>

Ternary added shortcut

• <?php
Constants added shortcut
– Can now use ternary for simpler $test = true;
returns of evaluation. // old way
– Instead of defining the ‘middle’ part $todo = ($test ? ‘Go’ : ‘Stop’);
of the operation we simply get a ‘1’ echo $todo;
if the first expression is true.
Otherwise we receive what is in the
third part, as we used to. // added shortcut
// if $test = true then we get a true flag, otherwise we get
the second expression as a result
$tada = ($test ?: ‘whatever’);

echo $tada;

?>

Output (true):
Go1

Output (false):
Stopwhatever

Questions and Resources


South Florida PHP Users Group

Adam Culp http://www.Geekyboy.com
Email: adam@geekyboy.com

Resources:
http://php.net/manual/en/migration53.new-
features.php

Intro to OOP and new features in PHP 5.3

More Related Content

What's hot (20)

Similar to Intro to OOP and new features in PHP 5.3 (20)

More from Adam Culp (20)

Recently uploaded (20)

Intro to OOP and new features in PHP 5.3