Detailed introduction to polymorphism and dynamic binding in php

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 in the form of overloading methods and inherited 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:

The code is as follows:

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

However, Type Hinting was introduced in PHP5.1, which can limit The parameter type of function (or method), we use this feature to demonstrate the polymorphism of 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 the parameter we pass to drawNow() may be Triangle Or a Rectangle object, or other derived class objects 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 passed in It is determined by the specific type of the parameters. 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 implementation 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?

HaoHappy translated PHP5 Object Pattern 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 Properties will be accessed by subclasses. 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.

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