As you know, PHP4 supports inheritance class syntax "class foo extends parent". In PHP4 And PHP5 class can only inherit one class, that is, multiple inheritance is not supported. Interface is called the classwhich is not realized any single method, identifies only the name and a set of parameters referred to them. Subsequently, classes can 'sell' any number of interfaces, thereby showing that a class implements the methods defined in the interface.

<? php
interface displayable (
function display ();
)

interface printable (
function doprint ();
)

class foo implements displayable, printable (
function display () (
/ / Code
)
/> Function doprint () (
/ / Code
)
)
">>

Using interfaces is useful for easy reading and understanding the code: Read the announcement of class, we can see that the class implements the interface displayable and printable; this means that the class must have methods of display () and doprint (). As these methods are implementeds - does not matter, the most important - from the class definition, you know that you can call these methods.

Abstract Classes

Is called an abstract class that can only be used as a base (that is to create objects of that class should not be). Kato normal in any base class, in the abstract class you can define methods and variables.

In the abstract class, you can also define abstract methods: methods that are not implemented in the abstract class, but that must be implemented in derived classes. />

Example 6: Abstract Classes

<? php
abstract class foo# 007700 "> (
protected $ x;

abstract function display ();

function setX ($ x) (
$ this -> > x = $ x;
)
)


class foo2 extends olor: # 0000bb "> foo (
function display () (
/ / Code
olor: # 007700 ">)
)
>

__call

With PHP5, you can implement in the class a special method __call (), as a method to "capture" all of the outstanding in this class of methods. Method__call (if defined) is called when trying to invoke a method unavailable or nonexistent.

Example 7: __call

<? php
class & n bsp; foo (

function __call ($ name, = "color: # 0000bb"> $ arguments) (
print ( "cause? I - $ name!");
)
)

or: # 0000bb "> $ x = new foo ();
$ x -> doStuffcolor: # 007700 ">();
$ x -> fancy_stuff ();
>

This ad hoc method can beused to implement overload methods: you can explore from the arguments and depending on the result of a suitable cause for this event closed method, for example:

Example 8: Overloading methods using __call

<? php
class Magic (

function __call yle = "color: # 007700"> ($ name, $ arguments) (
if ($ name> == 'Foo') (
if (is_int ($ arguments [ 0])) $ this -> foo_for_int ($ arguments an style = "color: # 007700"> [0]);
if (is_string ($ arguments or: # 007700 "> [0])) $ this -> foo_for_string ( > $ arguments [0]);
)
)

private function foo_for_int: # 007700 "> ($ x) (
print ( "a, look, a whole number!");
)

& nbsp; private function foo_for_string ($ x) (
print ( "a, look, string! ");
)
)

$ x = new Magic ();
: # 0000bb "> $ x -> foo (3);
$ x -> "color: # 0000bb"> foo ( "3");
>

__set and __get

But this is a e all, you can now define the methods and __get __set to "capture" all attempts to change or access to an uncertain (or inaccessible) variables.

Example 9: __set and __get

r: # 0000bb "> <? php
class foo (

function __set (# 0000bb "> $ name, $ val) (
print ( "Hi, you tried to assign the value $ val variable$ name ");
)

function __get ($ name) (
& nbsp; print ( "Hi, you tried to access $ name");
)
)

$ x = newfoo ();
$ x -> bar = 3 n style = "color: # 007700">;
print ($ x -> winky_winky);
>

In PHP5, you can "tell" method, that he should get in an argument to the object type.

Example 10: an indication of the types

tyle = "color: # 0000bb"> <? php
class foo (
/ / Code ...
)

cl ass bar (
public function process_a_foo (foo $ foo 07700 ">) (
/ / Even some code
)
)

$ b = newstyle = "color: # 0000bb"> bar ();
$ f = new foo ();
$ b process_a_foo ($ f);
>

As you notice, the nameargument, you can now put the name of his class, and thus PHP5 determines that the variable $ foo to be of class foo.

Static class members

Static members and static methods can be used for the realization of the fact that the PLO nazyvaetsI "class methods and class variables."

The static method of class "call a method that can be called without creating an object of this class.
"Variable-class" is called a variable to which you can apply without creating an object of this class (and access method is not required).

Example 11: Class methods and class variables

<? php
class: # 0000bb "> calculator (
static public $ pi = 3.14151692;

& nbsp; static public function add ($ x, $ y) (
&nbsp; return $ x + $ y;
)
)

$ s = Calculator:: $ pi;
$ result ="> calculator:: add (3, 7);
print ( result");
>

Exceptions

Exceptions - This universal approach to handling errors and unexpected situations in the German ykah as Java and C + +; in PHP5 intercepting exceptions implemented using a pair of "try" - "catch".

Example 12: Exceptions

<? php
: # 007700 "> class foo (

function divide ($ x, $ y) (
if ($ y == 0) throw new n style = "color: # 0000bb"> Exception ( "division by zero is inadmissible");
return $ x color: # 007700 "> / $ y;
)
)

$ x = new foo 00 ">();

try (
$ x -> divide (3, "color: # 0000bb"> 0);
) Catch (Exception $ e) (
echo $ e r: # 007700 "> -> getMessage ();
echo " n <br /> n";
color: # ff8000 "> / / Are there any draconian measures
)
>

As you can see, "try" is used to denote the block in which errors are processed by operatorsOromo "catch", which is at the end of the block. In the block "catch" you need to implement your own policies for handling errors. As a result, we obtain a legible code, and only one block of error handling.

The exceptions, user-defined To deal with unforeseen problems in your programs, you can define your own exceptions. All you have to - it's easy to supplement (extend) a class Exception, setting the class constructor and the method getMessage.

Example 13: Exceptions, ODA edelennye user

<? php
class WeirdProblem extends 0000bb "> Exception (

private $ data;

function WeirdProblem : # 007700 "> ($ data) (
parent:: exception or: # 007700 ">();
$ this -> data = $ datae = "color: # 007700">;
)

function getMessage () (
return $ this -> data. "aroused some strange exception!"
)
)
>

Then, for the initiation of certain exceptions to use the structure you throw new WeirdProblem ($ foo); if an exception occurs inside a block try (), it will transfer management of PHP5 to "catch"-block lengthI treatment.

Namespaces

For convenience, classes and functions can be grouped into namespaces (namespaces).

Note: The developers refused to poddrezhki this possibility.

Sample 14: Namespace

<? php
namespace Math (

class Complex"> (
//... code ...
function __construct () (
print ( "hello");
)
)
)

$ m = newMath:: Complex ();
>

Pay attention to the syntax of the use of personal space to indicate the class, subject totorogo we create. An example of practical application: the creation of corresponding classes in different names spaces, while the classes do different jobs (with the same interface).