8. Object Oriented Programming with PHP - PHP & MySQL Web Development
-
Upload
telerik-software-academy -
Category
Education
-
view
29.576 -
download
2
description
Transcript of 8. Object Oriented Programming with PHP - PHP & MySQL Web Development
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