Advance
OOP in PHP
OVERLOADING
• PHP Overloading can be broken down into two basic
components
• Method overloading
• Property overloading
• Overloading in PHP provides the means to dynamically
create members and methods via set of "magical" methods
• Invoked with interacting with members or methods that have
not been declared or are not visible in the current scope
• All of the magic methods must be declared as public
• None of the magic functions can be called with arguments,
passed by reference
OVERLOADING
• All overloading methods are invoked when accessing variable or
method that is not declared or is inaccessible
• __set($index, $value) – when writing (property
overloading)
• __get ($name) –when reading (property overloading)
• __call ($name, $arguments) - when calling a
method
OVERLOADING
• PHP "overloading" is a lot different from most
languages "overloading"
• Usually it means the ability to declare two methods
with different sets of parameters but same names
• Normally no property overloading
EXAMPLE
(METHOD OVERLOADING)
<?php • <?php
class MyClass{ class MyClass{
public function foo() {
public function foo() {
return "This is the foo function";
} return "This is the foo function";
}
} /*** __call() method with two args ***/
public function __call($method, $arg){
// create a new class object
echo $method.'<br />';
$obj = new MyClass;
$obj->bar(); print_r($arg);
?> }
}
$obj = new MyClass;
/*** call a non-existant method ***/
$obj->bar("arg1", "arg2");
5
?>
EXAMPLE (METHOD
<?php
OVERLOADING)
class readyGetSet {
private $item = 'Skate Board';
private $price = 100;
function __call($method, $arguments){
/*** set property and prefix ***/
$prefix = strtolower(substr($method, 0, 3));
$property = strtolower(substr($method, 3));
if (empty($prefix) || empty($property))
{
return;
}
if ($prefix == 'get' && isset($this->$property))
{
return $this->$property;
}
if ($prefix == 'set')
{
$this->$property = $arguments[0];
}
}
}
$obj = new readyGetSet; 6
echo 'Item: ' . $obj->getItem() . '<br />';
echo 'Price: ' . $obj->getPrice() . '<br />';
EXAMPLE (PROPERTY
OVERLOADING)
<?php <?php
class candy{
class candy{ public $type='chocolate';
/*** declare a property ***/ public $choctype = array('milk'=>0, 'dark'=
public $type='chocolate'; >1, 'plain'=>2);
public function wrap(){
/*** a normal method ***/ echo 'Its a wrap';
public function wrap(){ }
echo 'Its a wrap'; public function __get($index){
echo 'Retrieving element of $choctype pr
}
operty with index of '.$index.'<br />';
/*** our __set() function ***/ return $this->choctype[$index];
public function __set($index, $value){ }
echo 'The value of '.$index.' is '.$value;
} /*** end of class ***/
}
/*** a new candy object ***/
} /*** end of class ***/ $candy = new candy;
/*** set a non existant property ***/
7
echo 'The value of the following element pr
/*** a new candy object ***/ operty is '.$candy->milk;
$candy = new candy;
OBJECT ITERATION
• PHP provides a way for object to be iterated trough as a list of
items (array)
• foreach can be used
• By default iterates all visible properties
OBJECT ITERATION –
EXAMPLE
class A {
public $var1 = 1;
public $var2 = 2;
protected $var3 = 3;
private $var4 = 4;
function printIteration () {
foreach ($this as $key=>$val)
echo "$key : $val\n";
}
}
$obj = new A();
// this prints only the public properties
foreach ($obj as $key=>$val)
echo "$key : $val \n";
// this prints protected and private too
$obj->printIteration ();
OBJECT CLONING
• An object can be cloned with the clone keyword
$obj1 = new A();
$obj2 = clone $obj1;
• This will create new independent object
• Creating a copy of an object with fully replicated properties is not
always the wanted behavior
OBJECT CLONING
• A class can implement the magic method __clone
which is called for the newly created object
• Called "clone constructor"
• Allows necessary changes to be done on the newly
created object
• Example: Object holding reference to resource – the
new object must have new references, instead of
copies
• Example: Object holding reference to another object
that must not be copied
OBJECT CLONING
EXAMPLE
class A {
private $fileName;
private $fp = null;
public function open ($file) {
$this->fileName = $file;
$this->fp = fopen ($file, 'r');
}
public function close () {
if ($this->fp) {
fclose($this->fp);
$this->fp = null;
}
}
public function __clone () {
// reopen the file for the new object
if ($this->fp)
$this->fp= fopen($this->file, 'r');
}
}
SERIALIZING OBJECTS
• Serializing is the process of transforming an object into a string, that
can be stored
• This string can be used to restore the object
• Useful for storing objects in session data
• Saves only properties values and class names – no methods
• PHP provides the serialize and unserialize functions
SERIALIZING OBJECTS
• serialize ($object) – returns string, representing the object
• unserialize ($string) – returns new object, that is restored from
the serialized string
• unserialize requires the class to be defined before calling it
SERIALIZING OBJECT –
EXAMPLE
class A {
public $var;
public function myPrint () { echo $this->var; }
}
$obj = new A;
$obj->var = 10;
$data = serialize ($obj);
// store $data in a file
file_put_contents ('data.dat', $data);
// …
// in a new page:
$data = file_get_contents ('data.dat');
$obj = unserialize ($data);
$obj->myPrint (); // prints 10
SERIALIZING METHODS
• Before serializing and after unserializing PHP checks if
the class has the magic methods __sleep and
__wakeup
• __sleep allows the class to commit pending data,
cleanup or define what needs to be stored if the
object is very large
• Should return array with names of properties to be
stored
• __wakeup allows the class to restore connections or
other re-initialization
__SLEEP AND __WAKEUP
class Connection {
protected $link;
private $server, $user, $pass, $db;
public function __construct($server, $user,
$pass, $db) {
$this->server = $server;
$this->user = $user;
$this->pass = $pass;
$this->db = $db;
$this->connect();
}
private function connect () {
$this->link = mysql_connect (
$this->server, $this->user,
$this->pass);
mysql_select_db($this->db, $this->link);
}
// continues on next slide
__SLEEP AND __WAKEUP
// continues from previous slide
public function __sleep () {
// skip serializing $link
return array ('server', 'user',
'pass', 'db');
}
public function __wakeup () {
$this->connect();
}
}
NAMESPACES
• Namespaces in PHP are designed to resolve scope
problems in large PHP libraries
• Simplify development in object oriented
environment
• Clears the code – no long classes names
• In PHP all classes declarations are global
• Namespaces allow to have two classes with
same name
• Old approach was adding prefixes to class names
(Like the mysql_* functions)
• Available since PHP 5.3
NAMESPACE DEFINITION
• Namespaces are declared with the namespace keyword
• Should be always in the beginning of the file
<?
namespace Project;
class MyTemplate { … }
function print_headers () { … }
…
?>
• Namespace can contain classes, constants, functions but
no free code
NAMESPACES
• Classes, function and etc. in a namespace are automatically
prefixed with the name of the namespace
• So in the example we would use Project::MyTemplate to access
the class
• Constants in namespaces are defined with const keyword, not with
define
NAMESPACES – EXAMPLE
// file Project.php
namespace Project;
// declare base classes and etc.
…
// file project/db.php;
namespace Project::DB;
// declare DB interface for work with database
…
// file project/db/mysql.php
namespace Project::DB::MySQL;
// implement the DB interface for mysql
…
// file project/db/oracle.php
Namespace Project::DB::Oracle;
// implement the DB interface for Oracle
…
// somewhere in the project
require "project/db/mysql.php";
$a = new Project::DB::MySQL::Connection();
Project::DB::MySQL::connect();
USING NAMESPACES
• The use operator allows aliasing namespaces
names
use Project::DB::MySQL as DBLink;
$x = new DBLink::Connection();
DBLink::connect();
• If new name is not specified the namespace is
imported in the current context (global
namespace)
use Project::DB::MySQL;
$x = new MySQL::Connection();
MySQL::connect();
• Even if aliased, every class and function can be
accessed at any time by full name
AUTOLOADING CLASSES
• Usually every class is declared in separate file
• In big object oriented projects on every page you may have to
include dozens of files
• You can define __autoload function that is called when trying
to access class that is not defined
• It can include the necessary file for the class
AUTOLOAD EXAMPLE
<?
function __autoload ($class_name) {
$name = "includes/".$class_name.".inc.php";
if (file_exists ($name))
include $name;
else
echo 'Class not found';
}
?>
• Exceptions, thrown in __autoload cannot be caught and
result in fatal error
LIMITATION OF SELF::
• Example:
class A {
public static function whoami () {
echo __CLASS__;
}
public static function test () {
self::whoami();
}
}
class B extends A {
public static function whoami () {
echo __CLASS__;
}
}
B::test(); // outputs 'A' ?!
LATE STATIC BINDING
• PHP 5.3 introduces the late static binding which allows to
reference the called class in context of static
• In practice – this adds static:: scope
• So if in the above example we use static::whoami() in the
test() method body we get output 'B'
