Examples to explain PHP object-oriented polymorphism, examples to explain object-oriented

Explain object-oriented polymorphism in PHP with examples, explain object-oriented polymorphism with examples

What is polymorphism?

Polymorphism is the third feature of object-oriented languages after database abstraction and inheritance. Polymorphism refers to multiple forms and has the ability to express multiple forms. In object-oriented representations are handled differently depending on the type of object. Polymorphism allows each object to respond to a common message in its own way. Polymorphism enhances software flexibility and reusability.

If we create a doing() method, if it is a student, it will print for class, if it is a company employee, it will print for work.

Common practice

Use if judgment

Copy code The code is as follows:

/**
* PHP polymorphism
* Qiongtai Blog
*/

// Define student class
class student{
Public function cla(){
echo "Student workers are in class!
";
}
}

// Define staff class
class office{                                                                           public function Wor(){
echo "The staff is at work!
";
}
}

// Method to determine object type
function doing($obj){
If($obj instanceof student){
$obj->cla();
           }elseif($obj instanceof office){
$obj->wor();
         }else{
echo "No such object!";
}
}

doing(new student()); // The student is in class
doing(new office()); // The employee is working

The above result output:

Students are in class

The staff is working

This ordinary method has a disadvantage, that is, if there are many objects, the if..else.. will be very long and inflexible.

Polymorphism practices

Define a public abstract method, and all subclasses inherit it.

Copy code The code is as follows:

/**
* PHP polymorphism
* Qiongtai Blog
*/

//Define a public class
class pub{
protected function working(){
echo "This method needs to be overloaded in subclasses!";
}
}

// Define the student class and inherit the public class pub
class student extends pub{
Public function working(){
echo "Student workers are in class!
";
}
}

// Define the staff class and inherit the public class pub
class office extends pub{
public function working(){
echo "The staff is at work!
";
}
}

// Method to determine object type
function doing($obj){
If($obj instanceof pub){
$obj->working();
}else{
echo "No such object!";
}
}

doing(new student()); // The student is in class
doing(new office()); // The employee is working

This is the characteristic of polymorphism, flexible reuse.

Other ways From the perspective of the implementation of polymorphism, it is nothing more than standardizing that each class must override a method of the parent class to achieve a unified effect. When we define a class, it is also feasible to add unified methods ourselves. Therefore, the above example can also be implemented like this:

Copy code The code is as follows:

/**
* PHP polymorphism
* Qiongtai Blog
*/

// Define student class
class student{
// Define a unified method pub
Public function pub(){
echo "Student workers are in class!
";
}
}

// Define staff class
class office{
// Define a unified method pub
public function pub(){
echo "The staff is at work!
";
}
}

// Method to determine object type
function doing($obj){
If($obj){
// Call the unified method of the class
$obj->pub();
}else{
echo 'No such object';
}
}

doing(new student()); // The student is in class
doing(new office()); // The employee is working

Of course, the above examples do not mean that polymorphism can be achieved in this way. After all, polymorphism can effectively achieve flexible reuse in complex programming.

Polymorphism can also be understood as a programming method, and the ultimate goal of programming is nothing more than: flexibility, polymorphism, reuse, and efficiency.

What is object-oriented polymorphism?

The concept of object-oriented programming, object-oriented programming, has been pursued by programmers. The previous programming was process-oriented and could not be used for large-scale projects. Object-oriented programming can be said to be a revolution. It is more suitable for people. Thoughts, human thinking, rather than programming according to machine language thoughts! In C#, everything is an object! In fact, objects are not difficult to understand. For example: you are looking for a wife, what does your wife look like, how old is she, and what is her last name? , what job you do, how many boyfriends you have, etc. These are all characteristics of the object (wife).

When it comes to type conversion, there should be no need to say more about this!
As for the father The prerequisite for forced conversion of a class object into a subclass object is that the parent class object has the value of the subclass object, that is, the subclass object has been assigned to the parent class variable!
///
If it is a parent class If the object is converted to a subclass object, is the method (or attribute) of the parent class or the subclass called?

This is hard to explain. It will take a while to make it clear! There are many issues involved. Should subclasses hide or override the methods of the parent class? Besides, the parent class is abstract. Class, interface, etc. This requires detailed analysis of specific issues!
It is best to post your code to help you analyze!

The above is my understanding. If there is any mistake, please forgive me. !

Understanding of polymorphism in object-oriented

Simply put, polymorphism is the characteristic of having the ability to express multiple forms. In OO, it means that the language has the ability to process objects in different ways according to their types, especially in the form of overloaded methods and inherited classes. Polymorphism is considered an essential feature of object-oriented languages.

Polymorphism has many classifications. By understanding these classifications, you can understand it more fully. I will not list it here. Please refer to the wiki encyclopedia and javaworld.

Polymorphism and pan Type (generic)

Polymorphism is actually generics.

The so-called generic means that we do not code specifically for specific types, but use universal coding for different types, whether it is data results or algorithms.

Traditional generics refer to generalizing parameters in a way similar to Template function. Typical applications are C++ STL, such as List, Vector and algorithm.

And OO can already achieve true generics through interfaces and abstract classes. In my opinion, this is the most wonderful thing about OO, which is the power of polymorphism. As for Generic in the traditional sense, I always feel that its role is no longer what it used to be.

Polymorphism and inheritance (Inheritance)

Strictly speaking, polymorphism, inheritance and overloading are not isolated. There is a close connection between them. Polymorphism is based on this Based on the two (in fact, inheritance has the feature of overloading).

Traditional polymorphism is actually implemented by virtual function and virtual table (Virtual Table was most commonly used in early C to simulate OO features, as was the implementation of C++, and later technologies have not been studied. , it is unknown whether VT is used), naturally it is inseparable from inheritance. In other words, polymorphism actually covers inheritance.

It is precisely because of the close connection between inheritance and polymorphism that it is easy for us to pretend to be others, so how to distinguish them?

Take a commonly used example:

Abstract Class Sharp implement IHaveSide {
public bool isSharp(){
return true;
}
public abstract int getSides ();
}

Class Triangle extends Sharp {
public override int getSides() {
return 3;
}
}

Class Rectangle extends Sharp {
pubilc override int getSides() {
return 4;
}
}

Then this kind of relationship is called inheritance, and the following usage method is also brought about by inheritance. Here comes:
Triangel tri = new Triangle();
println("Triangle is a type of sharp? " + tri.isSharp());

And this method is polymorphic :
Sharp sharp = new Rectangle();
println("My sharp has " + sharp.getSides() + " sides.");

What is the difference between the two? Obviously, inheritance is a method for subclasses to use parent classes, while polymorphism is a method for parent classes to use subclasses.

The technical difference is the binding period, late binding must be polymorphic. ...The rest of the text>>