PHP5 Trial (ii)

PHP5 abstract class

Abstract classes cannot be instantiated.
Abstract classes, like other classes, allow you to define variables and methods.
An abstract class can also define an abstract method, and the method of an abstract class will not be executed, but it will be possible to execute it in its derived class.

Example VI: abstract class

<?php
Abstract class Foo {
protected $x;
Abstract function display ();
function SetX ($x) {
$this->x = $x;
}
}
Class Foo2 extends Foo {
function display () {
Code
}
}
?>


__call

The PHP5 object adds a dedicated method __call (), which is used to monitor other methods in an object. If you try to call a method that does not exist in an object, the __call method will be invoked automatically.

Example Seven: __call

<?php
class Foo {
function __call ($name, $arguments) {
Print ("Did You Call me?") I ' m $name! ");
}
} $x = new Foo ();
$x->dostuff ();
$x->fancy_stuff ();
?>

This particular method can be used to implement the "overload (overloading)" Action so that you can check your parameters and pass the arguments by calling a private method.

Example eight: Using __call to implement "overload" action

<?php
Class Magic {
function __call ($name, $arguments) {
if ($name = = ' Foo ') {
if (Is_int ($arguments [0])) $this->foo_for_int ($arguments [0]);
if (is_string ($arguments [0])) $this->foo_for_string ($arguments [0]);
}
Private Function Foo_for_int ($x) {
Print ("Oh an int!");
Private Function foo_for_string ($x) {
Print ("Oh a string!");
}
} $x = new Magic ();
$x->foo (3);
$x->foo ("3");
?>


__set and __get

This is a great way to __set and __get methods that can be used to capture variables and methods that do not exist in an object.

Example nine: __set and __get

<?php
class Foo {
function __set ($name, $val) {
Print ("Hello, tried to put $val in $name");
}
function __get ($name) {
Print ("Hey asked for $name");
}
}
$x = new Foo ();
$x->bar = 3;
Print ($x->winky_winky);
?>


Type indication

In PHP5, you can indicate in the object's method that its arguments must be an instance of another object.

Example Ten: Type indication

<?php
class Foo {
Code ...
}
Class Bar {
Public Function Process_a_foo (foo $foo) {
Some Code
}
}
$b = new Bar ();
$f = new Foo ();
$b->process_a_foo ($f);
?>

As you can see, we can explicitly indicate the name of an object before the argument, and PHP5 will recognize that this parameter will be an object instance.


Static members

Static members and static methods are referred to as Object methods (class methods) and object variables (class variables) in the terminology of object programming.
The object method is allowed to be invoked before an object is instantiated. Similarly, object variables can be manipulated independently of an object before it is instantiated (without the need for an object's method to control it).

Example 11: Object methods and Object variables

<?php
Class Calculator {
static public $pi = 3.14151692;
static public function Add ($x, $y) {
return $x + $y;
}
}
$s = calculator:: $pi;
$result = Calculator::add (3,7);
Print ("$result");
?>


Exception handling

Exception handling is an ideal way to deal with Bugs in Java and C + +, and we are delighted to see that PHP5 has been added to this application. You can try using "try" and "catch" to control the error.

Example 12: Exception handling

<?php
class Foo {
function Divide ($x, $y) {
if ($y ==0) throw new Exception ("Cannot divide by zero");
return $x/$y;
}
}
$x = new Foo ();
try {
$x->divide (3,0);
catch (Exception $e) {
echo $e->getmessage ();
echo "N<br/>n";
Some catastrophic measure here
}
?>

In the example above, we used "try" to execute the statement in curly braces. When there is an error, the code takes the error to the catch clause, and in the catch clause, you need to indicate that you want to give the error to an object, which makes the structure of the code look clearer. Because now we can give all the wrong information to an object to handle.


Custom error Handling

You can easily control the unexpected in your program with custom handling of the wrong code. You just need to derive your own error control class from the exception class, and in your own error control class you need to have a constructor and a GetMessage method, and here's an example.

Example 13: Custom error handling

<?php
Class Weirdproblem extends Exception {
Private $data;
function Weirdproblem ($data) {
Parent::exception ();
$this->data = $data;
}
function GetMessage () {
Return $this->data. "caused a weird exception!";
}
}
?>

Now we can use "throw new Weirdproblem ($foo)" to throw an error handle, if the error occurs in the code block of "Try", PHP5 automatically hands the error to the "Catch" section.


Name space

Namespaces are useful for grouping or grouping groups of classes. It can be combined with some related classes or functions to make it easier to call later.

Example 14: namespace

<?php
Namespace Math {
Class Complex {
... code ...
function __construct () {
Print ("Hey");
}
}
} $m = new Math::complex ();
?>

Notice where you need to use namespaces, and in practice, you might need to declare two or more names of objects to do different things, so you can put them in different namespaces (but the interfaces are the same).