Three major features in PHP5

Three major features in PHP5. These three features are as follows: * New Object Mode * Exception handling * Namespace two points must be declared before the start: * The example in this article describes how to perform the operation. some parts use the three major features of PHP4 table PHP5. These three features are:
　　
* New Object Mode)
　　
* Exception handling)
　　
* Namespace)
　　
Before you begin, you must declare two points:
　　
* The example in this article is to illustrate how to perform the operation. some parts use the PHP4 expression method, which is only to improve the readability of the article.
　　
* The part described in this article may differ from the final release version of PHP5.
　　
Before the final release of PHP5, you can download the latest build from the http://snaps.php.net at any time to experience the new features that PHP5 brings to us.
　　
　　 New Object Mode
　　
Objects in PHP5 have been adjusted systematically and comprehensively. the current situation may look similar to Java. This section describes the new object mode in PHP5 and provides some simple examples. Let this section be a new starting point for your PHP5 journey. :)
　　
* Constructor and Destructor
　　
* Object reference
　　
* Object cloning
　　
* Private, public, and protected modes in the object
　　
* Interface (Interfaces)
　　
* Abstract class
　　
* _ Call
　　
* _ Set and _ get
　　
* Static members
　　
　　 Constructor and Destructor
　　
In PHP4, when a function has the same name as an object, this function becomes the constructor of the object, and there is no destructor concept in PHP4.
　　
In PHP5, constructor is uniformly named as _ construct, and the concept of destructor is introduced. it is uniformly named as _ destruct.
　　
Example 1: constructor and Destructor
　　
　　 Class foo {
Var $ x;
Function _ construct ($ x ){
$ This-> x = $ x;
}
Function display (){
Print ($ this-> x );
}
Function _ destruct (){
Print ("bye ");
}
}
$ O1 = new foo (4 );
$ O1-> display ();
?>
In the above example, when you terminate the call to the foo class, the destructor will be called, and "bye" will be output in the above example ".
　　
　　 Object reference
　　
As we all know, in PHP4, when a variable is passed to a function or method, the variable is actually copied once, which means that you pass a copy of the variable to the function or method, unless you use the reference symbol "&" to declare that you want to make a reference, not a Copy. In PHP5, objects always exist as references, and assignment operations in objects are also a reference operation.
　　
Example 2: Object reference
　　
　　 Class foo {
Var $ x;
Function setX ($ x ){
$ This-> x = $ x;
}
Function getX (){
Return $ this-> x;
}
}
$ O1 = new foo;
$ O1-> setX (4 );
$ O2 = $ o1;
$ O1-> setX (5 );
If ($ o1-> getX () = $ o2-> getX () print ("Oh my god! ");
?>
　　
　　 Object cloning
　　
As mentioned above, when an object is always called as a reference, what should I do if I want a copy of the object? PHP5 provides a new function, namely object cloning, with the syntax of _ clone.
　　
Example 3: Object cloning
　　 Class foo {
Var $ x;
Function setX ($ x ){
$ This-> x = $ x;
}
Function getX (){
Return $ this-> x;
}
}
$ O1 = new foo;
$ O1-> setX (4 );
$ O2 = $ o1->__ clone ();
$ O1-> setX (5); if ($ o1-> getX ()! = $ O2-> getX () print ("Copies are independant ");
?>
The object cloning method exists in many other application languages, so you don't have to worry about its stability. :)
　　
　　 Private, public, and protection modes of objects
　　
In PHP4, all methods and variables of an object are public, which means that you can operate any of the variables and methods in an object's external operations. PHP5 introduces three new access control modes: Public, Protected, and Private ).
　　
Public mode: allows operation control outside the object.
　　
Private: only the methods in the object can be controlled.
　　
Protected Mode (Protected): allows this object and its parent object to control its operations.
　　
Example 4: private, public, and protected modes of objects
　　
　　 Class foo {
Private $ x;
Public function public_foo (){
Print ("I'm public ");
}
Protected function protected_foo (){
$ This-> private_foo (); // OK because we are in the same class we can call private methods
Print ("I'm protected ");
}
Private function private_foo (){
$ This-> x = 3;
Print ("I'm private ");
}
}
Class foo2 extends foo {
Public function display (){
$ This-> protected_foo ();
$ This-> public_foo ();
// $ This-> private_foo (); // Invalid! The function is private in the base class
}
} $ X = new foo ();
$ X-> public_foo ();
// $ X-> protected_foo (); // Invalid cannot call protected methods outside the class and derived classes
// $ X-> private_foo (); // Invalid private methods can only be used inside the class $ x2 = new foo2 ();
$ X2-> display ();
?>
　　
Tip: variables in an object always exist in private form. directly operating on variables in an object is not a good object-oriented programming habit, A better way is to hand over the variable you want to an object.
　　
　　 Interface (Interfaces)
　　
As we all know, objects in PHP4 support inheritance. to make an object a derived class of another object, you need to use code similar to "class foo extends parent" to control it. In PHP4 and PHP5, an object can only be inherited once. Multi-inheritance is not supported. However, a new term is generated in PHP5: interface, which is a special object without specific code processing. it only defines the names and parameters of some methods, the subsequent objects can easily use the 'enablement' keyword to integrate the required interfaces, and then add the specific execution code.
　　
Example 5: Interface
　　
　　 Interface displayable {
Function display ();
}
Interface printable {
Function doprint ();
}
　　
Class foo implements displayable, printable {
Function display (){
// Code
} Function doprint (){
// Code
}
}
?>
This is of great help to improve the readability and popularity of the code. from the example above, we can see that the object foo contains the displayable and printable interfaces, so we can clearly understand that, the object foo must have a display () method and a print () method. you only need to understand the Interface section, you can easily operate the object without having to worry about how the object operates internally.
　　
　　 Abstract class
　　
Abstract classes cannot be instantiated.
　　
Abstract classes, like other classes, allow definition of variables and methods.
　　
An abstract class can also define an abstract method. an abstract class method is not executed, but may be executed in its derived class.
　　
Example 6: abstract class
　　
　　 Abstract class foo {
Protected $ x;
Abstract function display ();
Function setX ($ x ){
$ This-> x = $ x;
}
}
Class foo2 extends foo {
Function display (){
// Code
}
}
?>
　　
　　 _ Call
　　
A special _ call () method is added to the PHP5 object. this method 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 automatically called.
　　
Example 7: __call
　　
　　 Class foo {
Function _ call ($ name, $ arguments ){
Print ("Did you call me? I'm $ name! ");
}
} $ X = new foo ();
$ X-> doStuff ();
$ X-> fancy_stuff ();
?>
　　
　　 _ Call
　　
This special method can be used to implement the "overload" action, so that you can check your parameters and pass parameters by calling a private method.
　　
Example 8: use _ call to implement "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. the __set and _ get methods can be used to capture variables and methods that do not exist in an object.
　　
Example 9: _ set and _ get
　　
　　 Class foo {
Function _ set ($ name, $ val ){
Print ("Hello, you tried to put $ val in $ name ");
}
Function _ get ($ name ){
Print ("Hey you asked for $ name ");
}