PHP advanced OOP technology demonstration_PHP tutorial

Serializing
PHP does not support persistent objects. In OOP, persistent objects are objects that can maintain state and functionality among references in multiple applications, which means having the ability to save objects to a file or database. , and the object can be loaded later. This is the so-called serialization mechanism. PHP has a serialization method that can be called on an object, and the serialization method can return a string representation of the object. However, serialization only saves the member data of the object and not the methods.
In PHP4, if you serialize the object into the string $s, then release the object, and then deserialize the object
into $obj, you can continue to use the object's methods! I don't recommend doing this because (a) there is no guarantee in the documentation that this behavior will still work in future versions. (b) This may lead to a misunderstanding when you save a serialized version to disk and exit the script. When you run this script later, you cannot expect that when you deserialize an object, the object's methods will be there, because the string representation does not include methods at all.
In short, serialization in PHP is very useful for saving member variables of objects. (You can also serialize related arrays and arrays into a file).
Example:

Copy code The code is as follows:

＜?php
$obj=new Classfoo() ;
$str=serialize($obj);
//Save $str to disk
//A few months later
//Load str from disk
　
$obj2=unserialize($str)

You restore the member data, but not the methods (according to the documentation). This results in the only way to access member variables (you have no other way!) by something like using $obj2->x, so don't try it at home.
There are some ways to solve this problem, I'm leaving them out because they are too bad for this concise article. I would happily welcome fully serialized features in subsequent versions of PHP.
Using Classes for Data Storage One of the great things about PHP and OOP is that you can easily define a class to operate on something and call the corresponding class whenever you want to use it. Suppose you have an HTML form that allows the user to select a product by selecting the product ID number. There is product information in the database, and you want to display the product, its price, etc. You have different types of products, and the same action may mean different things to different products. For example, displaying a sound might mean playing it, but for other kinds of products it might mean displaying an image stored in a database. You can use OOP or PHP to reduce coding and improve quality.
Define a product class, define the methods it should have (for example: display), and then define a class for each type of product
, derived from the product class (SoundItem class, ViewableItem class, etc. etc.), override the methods in the product class to make them act according to your ideas.
Name the class according to the type field of each product in the database. A typical product table may have (id, type, price, description, etc. fields)... Then in the processing script, you You can retrieve the type value from the database and instantiate an object named type:

Copy code The code is as follows:

＜?php
$obj=new $type();
$obj->action();

This is a very good feature of PHP. You can call the display method or other methods of $obj without considering the type of object. Using this technique, you don't need to modify the script to add a new type of object, just a class to handle it.
This function is very powerful, just define methods without considering the types of all objects, implement them in different classes in different methods, and then use them on any object in the main script, no if...else , no need for two programmers,
just happy.
Now you agree that programming is easy, maintenance is cheap, and reusability is true?
If you manage a group of programmers, assigning work is simple, each person may be responsible for a type of object and
the class that handles it.
Internationalization can be achieved through this technology, just apply the corresponding class according to the language field selected by the user, and so on.
Copy and Clone
When you create an object of $obj, you can copy the object by $obj2=$obj. The new object is a copy of $obj (not a reference), so it has $ The state of obj at that time. Sometimes, you don't want to do this. You just want to generate a new object like the obj class. You can call the constructor of the class by using the new statement. This can also be achieved in PHP through serialization and a base class, but all other classes must be derived from the base class.
Entering the danger zone
When you serialize an object, you will get a string in some format, and if you are interested, you can investigate it, where, in the string, there is the name of the class (great ! ), you can take it out, like:

Copy the code The code is as follows:

＜?php
$herring=serialize($obj);
$vec=explode(':',$herring);
$nam=str_replace(""",'',$vec[2]);

So assuming you create a "Universe" class and force all classes to extend from universe, you can define a clone method in universe, as follows:

Copy code The code is as follows:

＜?php
function clone() {
$herring=serialize($this);
$vec=explode(':',$herring);
$nam=str_replace(""",'',$vec[2]);
$ret=new $nam;
return $ ret;
}
}
//Then
$obj=new Something();
//Expand from Universe
$other=$obj->clone();

What you get is a new Something class object, which is the same as the object created by using the new method and calling the constructor. I don't know if this will work for you, but it's a good rule of thumb that the universe class knows the name of the derived class. Imagination is the only limit.
This statement is to write the current time.

http://www.bkjia.com/PHPjc/320543.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/320543.htmlTechArticleSerializing (Serializing) PHP does not support permanent objects. In OOP, permanent objects are references that can be used in multiple applications. An object that maintains state and functionality in a file, which means having to save the object to a file...