PHP implements parent calling the constructor method and overridden method of the parent class_PHP tutorial

php implements parent to call the constructor method of the parent class and the overridden method

This article mainly introduces the php implementation of parent to call the parent class constructor method and the overridden method. Based on the previous article about using class inheritance to solve the problem of code duplication, we further analyzed the related techniques of parent calling the parent class's construction method and being overwritten, which has certain reference value. Friends in need can refer to it

The example in this article describes how PHP implements parent to call the constructor method and overridden method of the parent class. Share it with everyone for your reference. The specific analysis is as follows:

Override: Redesigned.

When defining a constructor in a subclass, you need to pass parameters to the constructor of the parent class, otherwise we may get an incompletely constructed object.

To call the method of the parent class, you must first find a way to reference the class itself: handle. PHP provides the parent keyword for this.

parent calls the constructor of the parent class

To reference a method of a class rather than an object, use :: (two colons) instead of ->.

So, parent::__construct() means calling the __construct() method of the parent class.

Modify the code in the previous article "Using Class Inheritance to Solve Code Duplication and Other Problems" so that each class only processes its own data:

Copy the code The code is as follows:

header('Content-type:text/html;charset=utf-8');
// Starting from this article, the first letter of the class name must be capitalized, and the writing method is standardized
class ShopProduct{ // Declare class
public $title; // declare attributes
public $producerMainName;
public $producerFirstName;
public $price;
function __construct($title,$firstName,$mainName,$price){
$this -> title = $title; // Assign the passed value to the attribute title
$this -> producerFirstName= $firstName;
$this -> producerMainName = $mainName;
$this -> price= $price;
}
function getProducer(){ //Declaration method
return "{$this -> producerFirstName }"."{$this -> producerMainName}";
}
function getSummaryLine(){
$base = "{$this->title}( {$this->producerMainName},";
$base .= "{$this->producerFirstName} )";
return $base;
}
}
class CdProduct extends ShopProduct {
public $playLenth;
function __construct($title,$firstName,$mainName,$price,$playLenth){
parent::__construct($title,$firstName,$mainName,$price);
$this -> playLenth= $playLenth;
}
function getPlayLength(){
return $this -> playLength;
}
function getSummaryLine(){
$base = "{$this->title}( {$this->producerMainName},";
$base .= "{$this->producerFirstName} )";
$base .= "：playing time - {$this->playLength} )";
return $base;
}
}
// Define class
class BookProduct extends ShopProduct {
public $numPages;
function __construct($title,$firstName,$mainName,$price,$numPages){
parent::__construct($title,$firstName,$mainName,$price);
$this -> numPages= $numPages;
}
function getNumberOfPages(){
return $this -> numPages;
}
function getSummaryLine(){
$base = "{$this->title}( {$this->producerMainName},";
$base .= "{$this->producerFirstName} )";
$base .= "：page cont - {$this->numPages} )";
return $base;
}
}

?>

Each subclass calls the parent class's constructor before setting its own properties. The base class (parent class) now only knows its own data, and we should try to avoid telling the parent class any information about the subclass. This is a rule of thumb. Think about it if the information of a certain subclass should be "confidential" , as a result, the parent class knows its information, and other subclasses can inherit it, so that the subclass's information is not kept confidential.

parent calls the overridden method of the parent class

The parent keyword can be used in any method that overrides the parent class. When overriding a method of a parent class, we do not want to delete the function of the parent class, but extend it. This can be achieved by calling the method of the parent class in the current object.
Looking at the code above, you can find that a lot of code is repeated in the getSummaryLine() method in the two subclasses. We should make use of the functionality that already exists in the ShopProduct class instead of redundant development:

Copy the code The code is as follows:

// Parent class: ShopProduct
function getSummaryLine(){
$base = "{$this->title}( {$this->producerMainName},";
$base .= "{$this->producerFirstName} )";
return $base;
}
// Subclass: CdProduct
function getSummaryLine(){
$base = parent::getSummaryLine();
$base .= "：playing time - {$this->playLength} )";
return $base;
}
// Subclass: BookProduct
function getSummaryLine(){
$base = parent::getSummaryLine();
$base .= "：page cont - {$this->numPages} )";
return $base;
}

We have completed the "core" function for the getSummaryLine() method in the parent class ShopProduct, and then simply call the parent class method in the subclass, and then add more data to the summary string, and the method expansion is realized.

I hope this article will be helpful to everyone’s PHP programming design.

http://www.bkjia.com/PHPjc/956988.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/956988.htmlTechArticlephp implements the construction method and overridden method of parent calling the parent class. This article mainly introduces the php implementation of parent calling. The constructor method and overridden method of the parent class, in the previous article about using classes...