This article introduces object-oriented programming (OOP) in PHP. I'll demonstrate how to use object-oriented concepts to write better programs with less code. Good luck to everyone.
The concept of object-oriented programming has different views for each author. Let me remind you what an object-oriented language should have:
- Data abstraction and information hiding
- Inheritance
- Polymorphism
Used in PHP Class encapsulation method:
class Something {
// In OOP classes are usually named starting with a cap letter.
var $x;
function setX($v) {
// Me thods start in lowercase then use lowercase to seprate return $this->x;
}
}
?>
Of course you can use your own method, but it is always good to have a standard.
Data members of classes in PHP are defined using "var". Data members have no type until they are assigned a value. A data member may be an integer, an array, an associative array (associative array) or even an object. Methods are defined as functions in the class. To access data members in the method, you must use $this->name like this Method, otherwise it is a local variable of a function for the method.
Use new to create an object
$obj = new Something;
Then use the member function
$obj->setX(5);
$see = $obj->getX();
The setX member function will assign 5 Give the object (not the class) the member variables in obj, and then getX returns the value 5.
You can also use object references to access member variables, for example: $obj->x=6; However, this is not a good Object-oriented programming methods. I insist that you use member functions to set the value of member variables and member functions to read member variables. If you believe that member variables are not accessible except by using member functions, you will become a good object-oriented programmer. But unfortunately PHP itself has no way to declare a variable as private, so bad code is allowed to exist.
Inheritance in PHP is declared using extend.
class Another extends Something {
var $y;
function setY($v) {
Methods start in lowercase then use lowercase to seperate
// words in the method name example getValueOfArea()
$ this->y=$v;
}
function getY() {
return $this->y;
}
}
?>
In this way, the object of class "Another" has all the member variables of the parent class and Method function, plus its own member variables and member functions. For example:
$obj2=new Another;
$obj2->setX(6);
$obj2->setY(7);
Multiple inheritance is not supported, so you cannot let one class inherit multiple classes.
In inherited classes you can redefine to redefine methods. If we redefine getX in "Another", then we can no longer access the member function getX in "Something". Similarly, if we declare a If the member variable has the same name as the parent class, the inherited class variable will hide the parent class variable with the same name.
You can define a constructor of a class. The constructor is a member function with the same name as the class and is called when you create an object of the class.
class Something {
var $x;
function Something($y) {
$this->x=$y;
}
function setX($v) {
$this->x =$v;
}
function getX() {
return $this->x;
?
Structure The function automatically assigns the value 5 to the member variable x. The constructor and member functions are ordinary PHP functions, so you can use default parameters.
function Something($x="3",$y="5")
Then:
$obj=new Something(); // x=3 and y=5
$obj=new Something(8); / / x=8 and y=5
$obj=new Something(8,9); // x=8 and y=9
The default parameters are defined in the same way as in C++, so you cannot pass a value to Y but let X takes the default value, and the actual parameters are passed from left to right. When there are no more actual parameters, the function will use the default parameters.
Only when the constructor of the inherited class is called, the object of the inherited class is created, and the constructor of the parent class is not called. This is a feature of PHP that is different from other object-oriented languages, because the constructor call chain is object-oriented programming. Features. If you want to call the base class's constructor, you have to call it explicitly in the inheriting class's constructor. This works because all the methods of the parent class are available in the inherited class.
function Another() {
$this->y=5;
$this->Something(); //explicit call to base class constructor.
}
?>
In object-oriented A good mechanism in programming is to use abstract classes. An abstract class is a class that cannot be instantiated but is used to define an interface for inherited classes. Designers often use abstract classes to force programmers to only inherit from a specific base class, so they can be sure that the new class has the required functionality, but there is no standard way to do this in PHP, but:
If you This feature is needed when defining the base class, by calling "die" in the constructor, so you can ensure that it cannot be instantiated. Now define the functions of the abstract class and call "die" in each function. If you inherit If the programmer in the class does not want to redefine and directly calls the function of the base class, an error will occur. Additionally, you need to make sure that since PHP has no types, some objects are created from inherited classes that inherit from the base class, so add a method in the base class to identify the class (return "some identifier") and verify this when you receive Comes in handy to an object as a parameter. But there is no way for a rogue program, because he can redefine this function in the inherited class, usually this method only works for lazy programmers. Of course, the best way is to prevent the program from touching the base class code and only provide the interface.
Overloading is not supported in PHP. In object-oriented programming, you can overload a member function with the same name by defining different parameter types and numbers. PHP is a loosely typed language, so parameter type overloading is useless. Similarly, overloading with different number of parameters will not work.
Sometimes it is useful in object-oriented programming to overload constructors so you can create different objects in different ways (by passing a different number of parameters). A little trick can do this:
function Myclass() {
$name="Myclass".func_num_args();
$this->$name();
/ / Note that $this->$name() is usually wrong but here
//$name is a string with the name of the method to call.
}
function Myclass1($x) {
code; }
function Myclass2($x,$y) {
Myclass2($x,$y)
$obj1=new Myclass(1); //Will call Myclass1
$obj2=new Myclass(1,2); //Will call Myclass2
Feeling pretty good!
Polymorphism
Polymorphism is defined as the ability of an object to decide which method to call when an object is passed as a parameter at run time. For example, use a class to define the method "draw", and inherit the class to redefine the behavior of "draw" to draw a circle or a square, so that you have a function with a parameter of x , in which you can call $x->draw( ). If polymorphism is supported, then the call to the "draw" method depends on the type of object x . Polymorphism is naturally supported in PHP (think about this situation if compiled in a C++ compiler, which method is called? However, you don't know what the type of the object is, of course this is not the case now). Fortunately, PHP supports polymorphism.
function niceDrawing($x) {
//Supose this is a method of the class Board.
$x->draw();
}
$obj=new Circle(3,187);
$ obj2=new Rectangle(4,5);
$board->niceDrawing($obj); //will call the draw method of Circle.
$board->niceDrawing($obj2); //will call the draw method of Rectangle.
?>
Object-oriented programming in PHP
Pure object theorists believe that PHP is not a true object-oriented language, which is right. PHP is a hybrid language, you can use it with object-oriented or traditional structural programming methods. For large projects, however, you may or need to use a pure object-oriented approach to defining classes and use only objects and classes in your project. Larger and larger projects will benefit from using an object-oriented approach. Object-oriented projects are easier to maintain, easier to understand, and easier to reuse. This is the basis of software engineering. Using these concepts in website design is the key to future success.
Advanced Object-Oriented Techniques in PHP
After reviewing the basic concepts of object-oriented, I will introduce some more advanced techniques.
Serialization
PHP does not support persistent objects. In object-oriented languages, persistent objects are objects that retain their state and functionality after being called multiple times by the application. This means that there is a way to save objects to files or databases. and then reload the object. This mechanism is called serialization. PHP has a serialization function that can be called on an object. The serialization function returns a string representing the object. Then the serialization function saves the member data instead of the member function.
In PHP4, if you serialize an object to the string $s, then delete the object, and then deserialize the object to $obj, you can still call the object's method function. But I don't recommend this approach because (a) this feature may not be supported in the future and (b) it leads to a phantom if you save the serialized object to disk and exit the program. You cannot deserialize this object and expect the object's methods to still be valid when rerunning this script in the future, because the serialized string does not represent any member functions. Finally, serializing member variables of saved objects is very useful in PHP, and that's all. (You can serialize associative arrays and arrays to disk).
Example:
$obj=new Classfoo();
$str=serialize($obj);
//Save $str to disk
//...some months later
//Load str from disk
$obj2=unserialize($str)
?>
In the above example, you can restore member variables without member functions (according to the documentation). This results in $obj2->x being the only way to access member variables (since there are no member functions).
There are some other ways to solve this problem, but I leave it to you because it will mess up this clean document.
I hope PHP will fully support serialization in the future.
Use classes to manipulate saved data
One of the nice things about PHP and object-oriented programming is that you can easily define classes to manipulate something and call the appropriate class when needed. Suppose there is an HTML file and you need to select a product by selecting the product's ID number. Your data is saved in the database and you want to display the product's information, such as price, etc. You have different kinds of products, and the same action has different meanings for different products. For example, displaying a sound means playing it, while for other products it might be displaying an image stored in a database. You can do it using object-oriented programming and PHP, with less code but better.
Define a class, define the methods the class should have, and then define each product class (SoundItem class, ViewableItem class, etc.) through inheritance, and redefine the methods of each product class to make them what you need.Define a class for each product type based on the product type field of the table you store in the database. A typical product table would have fields (id, type, price, description, etc.). In the script you get the type information from the database table, and then instantiate the object of the corresponding class:
$obj=new $type();
$obj->action();
?>
This is a feature of PHP comparison. You can call the display method or other methods of $obj without caring about the type of the object. With this technique, you don't need to modify the script when you add a new type of object. This method is a bit powerful, it is to define the methods that all objects should have regardless of their type, and then implement them in different ways in different classes, so that they can be used for different types of objects in scripts, without if, No two programmers are ever happy in the same file. Do you believe that programming is such a joy? Low maintenance and reusable?
If you lead a group of programmers, the best way is to divide tasks so that each person can be responsible for certain classes and objects. Internationalization can be solved using the same techniques, making the appropriate classes correspond to the different languages chosen by the user, etc.
Copy and Clone
When you create an object $obj, you can use $obj2 = $obj to copy an object. The new object is a copy (not a reference) of $obj, so the new object has the same value as $obj after the assignment. new status. Sometimes you don't want this and just want to create a new object identical to obj and call the new object's constructor as if you had used the new command. This can be achieved through PHP's serialization and using a base class from which other classes must inherit.
Entering the Dangerous Zone
When you serialize an object, you get a string with a specific format. If you are curious, you may explore the secrets. One thing in the string is the name of the class. You You can unpack it:
$herring = serialize($obj);
$vec = explode(":",$herring);
$nam = str_replace(""", "", $vec[ 2]);
?>
Suppose you create a class "Universe" and make all classes inherit from "Universe", you can define a clone method in "Universe":
class Universe {
function __clone() { .
->__clone ();
?>
What you get is a new object of class Something just like using new , and the constructor is called and so on. I don't know if this will work for you, but it's a good practice that the Universe class knows the names of the classes it inherits from. The only limit for you is your imagination! ! !
Note: I am using PHP4, and some things in the article may not be suitable for PHP3.
-End-
The above introduces object-oriented programming in object-oriented PHP: the approach to large-scale PHP projects, including object-oriented aspects. I hope it will be helpful to friends who are interested in PHP tutorials.
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
