FFW Gabrovo PMG - PHP OOP Part 3

Object-Oriented Programming with PHP
Part 3
by Nikola Bintev

Table of contents
•Static methods and properties
•Constants
•Abstraction and interfaces
•Overloading
•Object Iteration
•Object Cloning
•Serialization
•Namespaces
•Autoloading Classes

•Defining method or property as 'static' makes
them accessible without needing an
instantiation of a class
–Accessed with the double-colon (::) operator
instead of the member (->) operator
–$this is not available in static methods
–Static properties and methods can also have scope
defined – public, private or protected

•Example of static method and property
–Class can access statics with the self keyword
–Outside world accesses statics with the class
name
class A {
public static $myVariable;
public static function myPrint() {
echo self::$myVariable;
}
}
A::$myVariable = 'test';
A::myPrint();

•Constants in PHP usually are declared with the
define function
•Constants can be defined in class
–Differ from normal variables – no need for $
symbol to declare and access
–Declared with the const keyword
–Value must be supplied with the declaration
–Accessed with scope operator (::)
–Can be overridden by child classes
–Value must be constant expression, not a
variable, class member, result of operation or
function call

•Example of a class constant
class A {
const myConstant = 'value';
public function showConstant() {
echo self::myConstant;
}
}
echo A::myConstant;
$obj = new A();
$obj->showConstant();

•Classes, defined as abstract, cannot have
instances (cannot create object of this class)
–Abstract methods do not have implementation
(body) in the class
•Only signature
–The class must be inherited
–The child class must implement all abstract
methods

abstract class AbstractClass {
abstract protected function getValue();
abstract public function getValue2($prefix);
public function printOut () {
echo $this->getValue();
}
}
class Class1 extends AbstractClass {
protected function getValue (){
return "Class1";
}
public function getValue2($prefix) {
return $prefix."NAC1";
}
}

// continue from previous slide
class Class2 extends AbstractClass {
protected function getValue (){
return "Class2";
}
public function getValue2($prefix) {
return $prefix."NAC2";
}
}
$class1 = new Class1();
$class1->printOut(); // "Class1";
echo $class1->getValue2('FOO'); // FOONAC1
$class2 = new Class2();
$class2->printOut(); // "Class2";
echo $class2->getValue2('FOO'); //FOONAC2

•Object interfaces allow you to specify what
methods a child class must implement
–Declared with the interface keyword
–Similar to abstract class
–Interface can have only public methods
–No method in interface can have implementation
•Interfaces are inherited with the implements
keyword (instead of extends)
–One class may implement multiple interfaces, if
they do not have methods with same names

interface iTemplate {
public function set ($name, $value);
public function getHTML($template);
}
class Template implements iTemplate {
private $vars = array();
public function set ($name, $value) {
$this->vars[$name] = $value;
}
public function getHTML($template) {
foreach($this->vars as $name=>$value) {
$template = str_replace('{'.$name.'}', $value, $template);
}
return $template;
}
}

•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

•All overloading methods are invoked when
accessing variable or method that is not
declared or is inaccessible
•__set($name, $value) – when writing
•__get ($name) –when reading
•__isset ($name) – when calling isset() function
•__unset ($name) – when calling unset()
function

•__call ($name, $arguments) - when calling a
method
•__callStatic ($name, $arguments) – when
calling a method in a static context
–Added after PHP 5.3
–Must always be declared as static
•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

•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

class A {
public $var1 = 1;
public $var2 = 2;
protected $var3 = 3;
private $var4 = 4;
function printIteration () {
foreach ($this as $key=>$val)
echo "$key : $valn";
}
}
$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 ();

•To take object iteration a step further, you can
implement one of the PHP interfaces
–Provided by the Standard PHP Library
–Allows the objects to decide what to show and
what not
–Some provided interfaces:
•Iterator – very long to implement but provides dull
features
•IteratorAggregate – simple version of Iterator interface
•ArrayIterator, DirectoryIterator, etc.

•An object can be cloned with the clone
keyword
–This will create new independent object
•Creating a copy of an object with fully
replicated properties is not always the wanted
behavior
$obj1 = new A();
$obj2 = clone $obj1;

–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

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 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

•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

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

•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

// continues from previous slide
public function __sleep () {
// skip serializing $link
return array ('server', 'user',
'pass', 'db');
}
public function __wakeup () {
$this->connect();
}
}

•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

•Namespaces are declared with the namespace
keyword
–Should be always in the beginning of the file
–Namespace can contain classes, constants,
functions but no free code
<?
namespace Project;
class MyTemplate { … }
function print_headers () { … }
…
?>

•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

// 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();

•The use operator allows aliasing namespaces
names
–If new name is not specified the namespace is
imported in the current context (global
namespace)
•Even if aliased, every class and function can be
accessed at any time by full name
use Project::DB::MySQL as DBLink;
$x = new DBLink::Connection();
DBLink::connect();
use Project::DB::MySQL;
$x = new MySQL::Connection();
MySQL::connect();

•By default PHP works in the global namespace
–All the project is executed there
–Method from the global namespace can be
referred to with empty scope operator
namespace Project::Files;
// this is the Project::Files::fopen function
function fopen (…) {
…
$f = ::fopen (…); // calls global fopen
…
}

•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

•Exceptions, thrown in __autoload cannot be
caught and result in fatal error
<?
function __autoload ($class_name) {
$name = "includes/".$class_name.".inc.php";
if (file_exists ($name))
include $name;
else
echo 'Class not found';
}
?>

•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' ?!

•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'

•Resources
–http://php-uroci.devbg.org/
–http://academy.telerik.com/
–http://www.codecademy.com/

FFW Gabrovo PMG - PHP OOP Part 3

Exercises [0]
1.Define class Student that holds information
about students: full name, course, specialty,
university, email, phone.
2.Define constructor for the class Student that
takes full name as parameter.
3.Add a method in the class Student for
displaying all information about the student.
4.Create two students and print their
information.
5.Create an interface IAnimal that represents
an animal from the real world. Define the

Exercises [1]
1.Create an abstract class Cat that has Name
and implements the interface IAnimal and
introduces abstract method printInfo().
2.Inherit from the base abstract class Cat and
create subclasses Kitten and Tomcat. These
classes should fully implement the IAnimal
interface and define an implementation for the
abstract methods from the class Cat.
3.Create class Dog that implements IAnimal.
4.Write a class TestAnimals that creates an
array of animals: Tomcat, Kitten, Dog and calls

Exercises [2]
1.We are given a school. In the school there are
classes of students. Each class has a set of
teachers. Each teacher teaches a set of
disciplines. Students have name and unique
class number. Classes have unique text
identifier. Teachers have name and title.
Disciplines have name, number of lectures and
number of exercises.
Define classes for the school (School, Class,
Student, Teacher, Discipline). Keep the member
fields private. Add constructors and accessor

FFW Gabrovo PMG - PHP OOP Part 3

More Related Content

What's hot (20)

Similar to FFW Gabrovo PMG - PHP OOP Part 3 (20)

More from Toni Kolev (6)

Recently uploaded (20)

FFW Gabrovo PMG - PHP OOP Part 3

Editor's Notes