PHP polymorphism and dynamic binding

This article mainly introduces PHP polymorphism and dynamic binding, explains what polymorphism and dynamic binding are, and examples of polymorphism and dynamic binding. I hope to be helpful.

What is polymorphism?

Polymorphism is the third feature of object-oriented languages ​​after data abstraction and inheritance. Literally understood, polymorphism means "multiple forms". Simply put, polymorphism is the characteristic of having the ability to express multiple forms. In OO, it means "the language has the ability to process objects in different ways depending on the type." , especially the ability to overload methods and inherit classes. Polymorphism is considered an essential feature of object-oriented languages.

For example:

We create an interface Shape and define an empty method draw(), then all implementation classes must implement this method. Assume that Shape has two implementation classes: Triangle and Rectangle, although we cannot interpret PHP's polymorphism through Java code like this:

Shape s = new Triangle();
s.draw();

However, Type Hinting was introduced in PHP5.1, which can limit the parameter types of functions (or methods). We use this feature to demonstrate polymorphism in PHP5.

Refer to the following code:

class TestPolymorphism {
    public function drawNow(Shape $shape) {
        $shape->draw();
    }
}

The function drawNow() restricts the parameter type passed in to an object derived from the Shape interface. Here we pass the parameters to drawNow() It may be a Triangle or Rectangle object, or it may be another derived class object of the Shape interface, such as Circle, etc. Simply put, the parameter type of drawNow() is unpredictable, and the behavior of $shape->draw() is ultimately It is determined by the specific type of the parameters passed in. For example, if a Triangle object is passed in, then the draw() method of Triangle is called. If a Rectangle object is passed in, the draw() method of Rectangle is called. This behavior of deciding which object method to call based on the type of object parameters passed at run time can be called polymorphism.

Shape can also be an abstract base class or a non-abstract base class. The above discussion is true. The difference is that the interface only defines a set of rules that the implementing class must comply with, while using a base class can provide some default behaviors for derived classes.

The reference code is as follows:

/**
 * Shape Interface
 * 
 * @version 1.0
 * @copyright 
 */
interface Shape {
    public function draw();
}
 
/**
 * Triangle 
 * 
 * @uses Shape
 * @version 1.0
 * @copyright
 */
class Triangle implements Shape {   
    public function draw() {
        print "Triangle::draw()\n";
    }
}
 
/**
 * Rectangle 
 * 
 * @uses Shape
 * @version 1.0
 * @copyright
 */
class Rectangle implements Shape {
    public function draw() {
        print "Rectangle::draw()\n";
    }
}
 
/**
 * Test Polymorphism
 * 
 * @version 1.0
 * @copyright
 */
class TestPoly {
    public function drawNow(Shape $shape) {
        $shape->draw();
    }
}
 
 
$test = new TestPoly();
$test->drawNow(new Triangle());
$test->drawNow(new Rectangle());
 
/* vim: set expandtab tabstop=4 shiftwidth=4: */

What is dynamic binding?

The PHP5 Object Pattern translated by HaoHappy is introduced in Section 9:

In addition to restricting access, the access method also determines which method will be called by the subclass or which attribute will be accessed by the subclass. The relationship between function calls and the function itself, and the relationship between member access and variable memory addresses, is called binding.

Another way of saying it:

Binding: Connecting the method call to the method itself is called binding. When binding occurs at compile time, it is called static binding. When the program is running, the binding method is determined based on the type of the object and becomes dynamic binding.

PHP is a dynamic language that uses dynamic binding. There is no need to consider which binding strategy to adopt, because everything is automatic.

Related recommendations:

PHP object-oriented final class and final method

PHP singleton mode implementation

PHP factory mode usage method_PHP tutorial

The above is the detailed content of PHP polymorphism and dynamic binding. For more information, please follow other related articles on the PHP Chinese website!