Introduction to PHP5 polymorphism and dynamic binding, php5 polymorphic dynamic binding

Introduction to PHP5 polymorphism and dynamic binding, php5 polymorphic dynamic binding_PHP tutorial

WBOY

Release： 2016-07-13 09:58:03

Original

911 people have browsed it

Introduction to PHP5 polymorphism and dynamic binding, php5 polymorphic dynamic binding

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 pass Java code like this To explain PHP polymorphism:
Copy code The code is as follows:
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 the polymorphism of PHP5.

Refer to the following code:
Copy code The code is as follows:
class TestPolymorphism {
Public function drawNow(Shape $shape) {
$shape->draw();
}
}

The parameter type passed in the function drawNow() is restricted to be an object of a derived class of the Shape interface. The parameters we pass to drawNow() here may be a Triangle or Rectangle object, or they may be other derived class objects of the Shape interface, such as Circle, etc. Simply put, the parameter type of drawNow() is unpredictable. The behavior of $shape->draw() is ultimately determined by the specific type of the parameter passed in. For example, if a Triangle object is passed in, then Call the draw() method of Triangle. If a Rectangle object is passed in, call the draw() method of Rectangle. 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:
Copy code The 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 property 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 a method call to the method itself is called binding. When binding occurs at compile time, it is called static binding. It is determined according to the type of object when the program is running. This binding method is called dynamic binding.

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