Object-Oriented Programming with

PHPMethods, Classes, Objects, Abstraction

Nikolay Kostov

Telerik Software Academyacademy.telerik.com

Technical Trainerhttp://nikolay.it

http://academy.telerik.com/.../php-school-academy-meeting

Summary

Classes and objects Methods and properties Scope Inheritance Static methods and properties Constants Abstraction and interfaces

Summary (2)

Overloading Object Iteration Object Cloning Serialization Namespaces Autoloading Classes

Classes and Objects The idea of Object Oriented Programming is to move the architecture of an application closer to real world Classes are types of entities

Objects are single units of a given class

Example – Dog is a class, your dog Lassie is an object of class Dog

Classes have methods and properties

Classes and objects help to create well-structured application

Classes in PHP Declaring of a class in PHP can be done anywhere in the code

Two special methods: constructor and destructor Executed when creating or

destroying new object of this class

Used to initialize or cleanup properties and etc.

class Dog {… // declare methods and properties

}

class Dog {… // declare methods and properties

}

Classes in PHP Class definition begins with the class keyword, followed by its name and methods and properties list

Objects of class (instances) are created with the keyword new

class A {function foo () {

echo "foo here!";}

}$myFirstObject = new A();$myFirstObject->foo(); // prints out "foo here!";

class A {function foo () {

echo "foo here!";}

}$myFirstObject = new A();$myFirstObject->foo(); // prints out "foo here!";

class nameMethod name and body

Create new object of class A

Execute method of this object

Constructors Each class can have only one constructor

All parameters of the creating of the object are passed to the constructor

class A {function __construct ($bar) {

echo $bar;}function foo () {

echo "foo here!";}

}$myFirstObject = new A('test'); // print 'test'

class A {function __construct ($bar) {

echo $bar;}function foo () {

echo "foo here!";}

}$myFirstObject = new A('test'); // print 'test'

Properties Class can have unlimited number of

properties

The $this variable points to the current object – called execution context

class A {var $bar;function __construct ($bar) {

$this->bar = $bar;}function myPrint () {

echo $this->bar;}}$myFirstObject = new A('test'); $myFirstObject->myPrint();

class A {var $bar;function __construct ($bar) {

$this->bar = $bar;}function myPrint () {

echo $this->bar;}}$myFirstObject = new A('test'); $myFirstObject->myPrint();

More Properties Class can specify default value for a property

Properties can be accessed from the outside world

class A {var $bar = 'default value';…

class A {var $bar = 'default value';…

class A {var $bar = 'default value';…

}$obj = new A;echo $obj->bar;

class A {var $bar = 'default value';…

}$obj = new A;echo $obj->bar;

$this Example of what $this is

Can be used to access methods too

class A {var $bar;function __construct ($bar) {

$this->bar = $bar;}function myPrint () {

echo $this->bar;}}$myFirstObject = new A('test'); $myFirstObject->myPrint(); // prints 'test'$anotherObject = new A('foo'); $anotherObject ->myPrint(); // prints 'foo';

class A {var $bar;function __construct ($bar) {

$this->bar = $bar;}function myPrint () {

echo $this->bar;}}$myFirstObject = new A('test'); $myFirstObject->myPrint(); // prints 'test'$anotherObject = new A('foo'); $anotherObject ->myPrint(); // prints 'foo';

Destructors Each class can have only one destructor Must be public

Destructors are automatically called when script is shutting down

class A {function __construct ($name) {

$this->fp = fopen ($name, 'r');}function __destruct () {

fclose($this->fp);}

}$myFirstObject = new A('test');

class A {function __construct ($name) {

$this->fp = fopen ($name, 'r');}function __destruct () {

fclose($this->fp);}

}$myFirstObject = new A('test');

Scope Each method and property has a scope

It defines who can access it Three levels – public, protected,

private Private can be access only by the object

itself

Protected can be accessed by descendant classes (see inheritance)

Public can be accessed from the outside world

Level is added before function keyword or instead of var var is old style (PHP 4) equivalent to

public Constructors always need to be

public

Scope Example

class A {private $bar;public function __construct ($bar) {

$this->bar = $bar;}public function myPrint () {

echo $this->bar;}}

$myFirstObject = new A('test'); $myFirstObject->myPrint(); // prints 'test'// this will not work:echo $myFirstObject->bar;

class A {private $bar;public function __construct ($bar) {

$this->bar = $bar;}public function myPrint () {

echo $this->bar;}}

$myFirstObject = new A('test'); $myFirstObject->myPrint(); // prints 'test'// this will not work:echo $myFirstObject->bar;

The $bar variable is private so only the object can access itThe myPrint method is

public, so everyone can call it

Inheritance A class can inherit (extend) another

class

It inherits all its methods and properties

class A {public $bar = 'test';public function example () {

…}

}class B extends A {

…}$obj = new B();echo $obj->bar; //prints 'test'//calls the A-class function$obj->example();

class A {public $bar = 'test';public function example () {

…}

}class B extends A {

…}$obj = new B();echo $obj->bar; //prints 'test'//calls the A-class function$obj->example();

Protected Scope Method or property, declared as protected can be accessed in classes that inherit it, but cannot be accessed from the outside worldclass A {

protected $bar = 'test';}class B extends A {

public function foo () {// this is allowed$this->bar = 'I see it';

}}$obj = new B();echo $obj->bar; //not allowed

class A {protected $bar = 'test';

}class B extends A {

public function foo () {// this is allowed$this->bar = 'I see it';

}}$obj = new B();echo $obj->bar; //not allowed

Overriding When a class inherits another, it can declare methods that override parent class methods Method names are the same

Parameters may differclass A {

public foo() { … }}class B extends A {

public foo() { … }}

class A {public foo() { … }

}class B extends A {

public foo() { … }}

Overriding Example

class A {public foo() {

echo 'called from A';}

}class B extends A {

public foo() {echo 'called from B';

}}$obj1 = new A();$obj2 = new B();$obj1->foo(); // executes A's methods$obj2->foo(); // executes B's methods

class A {public foo() {

echo 'called from A';}

}class B extends A {

public foo() {echo 'called from B';

}}$obj1 = new A();$obj2 = new B();$obj1->foo(); // executes A's methods$obj2->foo(); // executes B's methods

Accessing Parent Class As -> is used to access object's methods and properties, the :: (double colon) is used to change scope Scope Resolution Operator

parent:: can be used to access parent's class overridden methods Example: call parent's constructor

in the child one

Accessing Parent Class Example of calling parent constructorclass A {

protected $variable;public __construct() {

$this->variable = 'test';}

}class B extends A {

public __construct() {parent::__construct();echo $this->variable;

}}$obj1 = new B();// prints 'test';

class A {protected $variable;public __construct() {

$this->variable = 'test';}

}class B extends A {

public __construct() {parent::__construct();echo $this->variable;

}}$obj1 = new B();// prints 'test';

The static Keyword 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

The static Keyword 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();

class A {public static $myVariable;public static function myPrint() {

echo self::$myVariable;}

}A::$myVariable = 'test';A::myPrint();

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

Class Constants Example of a class constant

class A {const myConstant = 'value';

public function showConstant() {echo self::myConstant;

}}

echo A::myConstant;

$obj = new A();$obj->showConstant();

class A {const myConstant = 'value';

public function showConstant() {echo self::myConstant;

}}

echo A::myConstant;

$obj = new A();$obj->showConstant();

Abstraction Classes, defined as abstract, cannot

have instances (cannot create object of this class)

Abstract class must have at least one abstract method

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

Cannot increase visibility

Abstraction Example

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";}

}

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";}

}

Abstraction Example (2)

// continue from previous slideclass 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

// continue from previous slideclass 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

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

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

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

Overloading Methods __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

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 propertiesforeach ($obj as $key=>$val)

echo "$key : $val \n";// this prints protected and private too$obj->printIteration ();

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 propertiesforeach ($obj as $key=>$val)

echo "$key : $val \n";// this prints protected and private too$obj->printIteration ();

Object Iteration 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.

Object Cloning 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;$obj1 = new A();$obj2 = clone $obj1;

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 objectif ($this->fp)

$this->fp= fopen($this->file, 'r');

}}

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 objectif ($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 filefile_put_contents ('data.dat', $data);

// …

// in a new page:$data = file_get_contents ('data.dat');$obj = unserialize ($data);$obj->myPrint (); // prints 10

class A {public $var;public function myPrint () { echo $this->var; }

}

$obj = new A;$obj->var = 10;$data = serialize ($obj);// store $data in a filefile_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

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 $linkreturn array ('server', 'user',

'pass', 'db');}

public function __wakeup () {$this->connect();

}}

// continues from previous slide

public function __sleep () {// skip serializing $linkreturn 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 can contain classes, constants, functions but no free code

<?namespace Project;

class MyTemplate { … }function print_headers () { … }…?>

<?namespace Project;

class MyTemplate { … }function print_headers () { … }…?>

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.phpnamespace Project; // declare base classes and etc.…// file project/db.php;namespace Project::DB; // declare DB interface for work with database…// file project/db/mysql.phpnamespace Project::DB::MySQL;// implement the DB interface for mysql…// file project/db/oracle.phpNamespace Project::DB::Oracle;// implement the DB interface for Oracle…// somewhere in the projectrequire "project/db/mysql.php";$a = new Project::DB::MySQL::Connection();Project::DB::MySQL::connect();

// file Project.phpnamespace Project; // declare base classes and etc.…// file project/db.php;namespace Project::DB; // declare DB interface for work with database…// file project/db/mysql.phpnamespace Project::DB::MySQL;// implement the DB interface for mysql…// file project/db/oracle.phpNamespace Project::DB::Oracle;// implement the DB interface for Oracle…// somewhere in the projectrequire "project/db/mysql.php";$a = new Project::DB::MySQL::Connection();Project::DB::MySQL::connect();

Using Namespaces 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 as DBLink;$x = new DBLink::Connection();DBLink::connect();

use Project::DB::MySQL;$x = new MySQL::Connection();MySQL::connect();

use Project::DB::MySQL;$x = new MySQL::Connection();MySQL::connect();

Global Namespace 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 functionfunction fopen (…) {

…$f = ::fopen (…); // calls global fopen…

}

namespace Project::Files;// this is the Project::Files::fopen functionfunction fopen (…) {

…$f = ::fopen (…); // calls global fopen…

}

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

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';}?>

<?function __autoload ($class_name) {

$name = "includes/".$class_name.".inc.php";if (file_exists ($name))

include $name;else

echo 'Class not found';}?>

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

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'

форум програмиране, форум уеб дизайнкурсове и уроци по програмиране, уеб дизайн – безплатно

програмиране за деца – безплатни курсове и уроцибезплатен SEO курс - оптимизация за търсачки

уроци по уеб дизайн, HTML, CSS, JavaScript, Photoshop

уроци по програмиране и уеб дизайн за ученициASP.NET MVC курс – HTML, SQL, C#, .NET, ASP.NET MVC

безплатен курс "Разработка на софтуер в cloud среда"

BG Coder - онлайн състезателна система - online judge

курсове и уроци по програмиране, книги – безплатно от Наков

безплатен курс "Качествен програмен код"

алго академия – състезателно програмиране, състезания

ASP.NET курс - уеб програмиране, бази данни, C#, .NET, ASP.NETкурсове и уроци по програмиране – Телерик академия

курс мобилни приложения с iPhone, Android, WP7, PhoneGap

free C# book, безплатна книга C#, книга Java, книга C#Дончо Минков - сайт за програмиранеНиколай Костов - блог за програмиранеC# курс, програмиране, безплатно

?

? ? ??

?? ?

?

?

?

??

?

?

? ?

Questions?

?

Object-Oriented Programming with PHP

http://academy.telerik.com

Exercises1. 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 method talk() that prints the specific scream of the animal ("jaff" for dogs, "muaw" for cats, etc.).

Exercises (2)6. Create an abstract class Cat that has Name

and implements the interface IAnimal and introduces abstract method printInfo().

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

8. Create class Dog that implements IAnimal.

9. Write a class TestAnimals that creates an array of animals: Tomcat, Kitten, Dog and calls their methods through IAnimal interface to ensure the classes are implemented correctly.

Exercises (3)

10. 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 methods. Write a testing class to construct and print a sample school.

Exercises (4)

11. We need to implement a message board where visitor can read all messages, add new messages, edit and delete existing messages.

Implement this as a PHP application by following the steps below: Create a MySQL database Messages

and define in it a table messages(id, author, subject, msgDate, msgBody).

Write a class Message which will hold a single message with its id, author, subject, msgDate and msgBody. Put this class in the file message.class.php.

Exercises (5) Write a class DBUtils which will be

responsible for database access for the entire application. Put this class in the file db-utils.class.php. Implement the following methods: dbConnect() – connects to the MySQL

database and selects Messages database getAllMessages() – returns an array of Message objects containing all messages from the database

addMessage($msg) – inserts a message given as Message object to the database

updateMessage($msg) – updates a message given as Message object in the database

deleteMessageById($msg_id)- deletes given message specified by its primary key

Exercises (6) Write a PHP script index.php which

displays all messages in a table.

Implement a form for adding a message as separate script add-message.php.

Implement deleting of a message by clicking a hyperlink in the corresponding row in the table. Implement it as separate script delete.php.

Implement editing of a message by clicking on a hyperlink in the corresponding row in a table. Implement it as separate script edit-message.php.

Free Trainings @ Telerik Academy

“PHP & MySQL Web Design" course

academy.telerik.com/.../php-school-academy-meeting

Telerik Software Academy academy.telerik.com

Telerik Academy @ Facebook facebook.com/TelerikAcademy

Telerik Software Academy Forums forums.academy.telerik.com