Preliminary study on PHP5 (II.) _php

Abstract class

Abstract classes cannot be instantiated.
Abstract classes, like other classes, allow you to define variables and methods.
Abstract classes can also define an abstract method, and the methods of the abstract class will not be executed, although they may be executed in their derived classes.

Example VI: abstract class

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 has a new dedicated method, __call (), which is used to monitor other methods in an object. If you try to invoke a method that does not exist in an object, the __call method will be called automatically.

Example VII: __call

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

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

Example VIII: Using __call to achieve "overload" action

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 method, and the __set and __get methods can be used to capture variables and methods that do not exist in an object.

Example IX: __set and __get

class Foo {
function __set ($name, $val) {
Print ("Hello, you tried-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 an object's method that its argument must be an instance of another object.

Example Ten: Type indication

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 method (class methods)" and "Object variable (class variables)" In the terminology of polygon object programming.
The object method is allowed to be called before an object is instantiated. Similarly, an "object variable" can be controlled independently of an object before it is instantiated (it does not need to be controlled by an object's method).

Example 11: Object methods and Object variables

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 program errors in Java and C + +, and we are delighted to see that PHP5 has joined this application. You can try using "try" and "catch" to control the error.

Example 12: Exception handling

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
n ";
Some catastrophic measure here
}
?>

In the example above, we use "Try" to execute the statement in curly braces, and when an error occurs, the code gives 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 to handle, which makes the code structure look clearer. Because now we can give all the error 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

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, and if the error occurs in the code block of "Try", PHP5 will automatically give the error to the "Catch" section for processing.

Name space

Namespaces are useful for grouping or grouping functions on a class. It can combine some related classes or functions to make it easier to call later.

Example 14: namespaces

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

Note that you need to use namespaces in situations where you might want to declare two or more names of objects to do different things, and then you can put them in separate namespaces (but the interface is the same).

Translator Note: This article from Phpbuilder, from the above text we are pleased to see the PHP5 in the new additions to some of the outstanding features. We can also see some Java and C + + shadow, now the PHP5 has not officially released, wait until the actual release that day, hoping to bring all the PHP enthusiasts more surprises. Friends who are more interested in this area can log in to the official PHP newsgroup to learn about the update. The newsgroup address is news://news.php.net and can also be accessed by logging in to the Web interface http://news.php.net. Let's look forward to the release of the new version. :) (Beyond PHP Avenger)

