Home > Article > Backend Development > Application of polymorphism in php classes_PHP tutorial
Application of polymorphism in php classes_PHP tutorial
- WBOYOriginal
- 2016-07-20 11:10:081048browse
Application of polymorphism in PHP tutorial class
Instanceof: used to determine whether a given object comes from a specified object class
class A{}
class B{}
$thing=new A();
//return true
if ($thing instanceof A) {
echo 'A';
}
//return false
if ($ thing instanceof B) {
echo 'B';
}
?>
Run result:
A
header("Content-Type:text/html;charset=UTF-8") ;
interface MyUsb{
function type();
function alert();
}
class Zip implements MyUsb{
function type(){
echo "2.0";
}
function alert(){
echo "Checking U disk driver";
}
}
class Mp3 implements MyUsb{
function type(){
echo "1.0";
}
function alert(){
echo "Checking MP3 driver";
}
}
class Mypc{
function PcUsb($what)
{
$what->type();
$what->alert();
}
}
$pc=new Mypc();
$zip=new Zip();
$mp3=new Mp3();
$pc->PcUsb($zip);//When a USB flash drive is plugged in
echo "
";
$pc->PcUsb($mp3);//When the MP3 is plugged in
?>
Run results:
2.0 is checking the USB drive
1.0 is checking the MP3 driver
Object references are all the same regardless of parent class reference or child class reference Class reference. Let's look at an example now. First of all, to use polymorphism, there must be a relationship between parent class objects and subclass objects. Make a shape interface or abstract class as the parent class. There are two abstract methods in it, one is to find the perimeter, and the other is to find the area. The subclasses of this interface are a variety of different shapes, each Shapes have perimeter and area, and because the parent class is an interface, the subclass must implement the two abstract methods of perimeter and area of the parent class. The purpose of this is to make the subclass of each different shape All classes comply with the specifications of the parent class interface and have methods for calculating perimeter and area.
The code is as follows:
//Defines a shape interface, which has two abstract methods for subclasses to implement
interface Shape{
function area();
function perimeter();
}
//Defines a rectangle subclass that implements the perimeter and area in the shape interface
class Rect implements Shape{
private $width;
private $height;
function __construct($width, $height){
$this->width=$width;
$this->height=$height;
}
function area(){
return "The area of the rectangle is: ".($this->width*$this->height);
}
function perimeter(){
return " The perimeter of the rectangle is: ".(2*($this->width+$this->height));
}
}
//Defines a circle subclass to implement the shape Perimeter and area in the interface
class Circular implements Shape{
private $radius;
function __construct($radius){
$this->radius=$radius;
}
function area(){
return "The area of the circle is:".(3.14*$this->radius*$this->radius);
}
function perimeter(){
return "The circumference of a circle is:".(2*3.14*$this->radius);
}
}
//Assign the subclass rectangle object to one of the shapes Quote
$shape=new Rect(5, 10);
echo $shape->area()."
";
echo $shape->perimeter()."< ;br>";
//Assign the subclass circular object to a reference of the shape
$shape=new Circular(10);
echo $shape->area()."< br>";
echo $shape->perimeter()."
";
?>
Execution result of the above example:
Execution result
Rectangle The area of the circle is: 50
The perimeter of the rectangle is: 30
The area of the circle is: 314
The perimeter of the circle is: 62.8
We can see from the above example that the rectangular object and The circular objects are assigned to the variable $shape respectively. When the area and perimeter methods of
in the $shape reference are called, different results appear. This is a polymorphic application. In fact, in our weak PHP
In a typed object-oriented language, the feature of polymorphism is not particularly obvious. It is actually the application of variables
for object type variables.