PHP implements the constructor method of parent call parents and the method of overwriting, parent _php tutorial

PHP implements the constructor of the parent call to the method with the overridden

In this paper, we describe the method of constructing and overwriting the parent class by the implementation of PHP. Share to everyone for your reference. The specific analysis is as follows:

Overwrite: redesigned.

When you define a constructor method in a subclass, you need to pass arguments to the constructor of the parent class, otherwise we might get an object that is not fully constructed.

To invoke the method of the parent class, first find a way to refer to the class itself: handle (handle), PHP provides the parent keyword for this purpose.

Parent calls the construction method of the parents class

To refer to a method of a class instead of an object, you can use:: (two colons) instead of.

So, parent::__construct () thought to call the __construct () method of the parent class.

Modify the code in the previous article, "Using class inheritance to resolve code duplication," so that each class only processes its own data:
Copy CodeThe code is as follows: <?php
Header (' Content-type:text/html;charset=utf-8 ');
From this beginning, the first letter of the class name is capitalized, the canonical wording
Class shopproduct{//declaring classes
public $title; declaring properties
Public $producerMainName;
Public $producerFirstName;
Public $price;
function __construct ($title, $firstName, $mainName, $price) {
$this title = $title; Value passed in to 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;
}
}
Defining classes
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 invokes the construction method of the parent class 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 subclasses, this is a rule of thumb, people think that if a subclass of information should be "confidential", the result of the parent class know its information, other subclasses can inherit, this kind of information is not confidential.

Parent calls a method that is overridden by the parental class

The parent keyword can be used in any method that override the parent class. When we overwrite a method of a parent class, we do not want to remove the function of the parent class, but extend it to do so by invoking the method of the parent class in the current object.
Looking at the code above, you can see that there are a lot of code repeated in the Getsummaryline () method in the two subclasses, and we should take advantage of the functionality already in the Shopproduct class, rather than repeating the development:
Copy the Code Code as follows://parent class: Shopproduct
function Getsummaryline () {
$base = "{$this->title} ({$this->producermainname},";
$base. = "{$this->producerfirstname})";
return $base;
}
Sub-Category: Cdproduct
function Getsummaryline () {
$base = Parent::getsummaryline ();
$base. = ": Playing time-{$this->playlength})";
return $base;
}
Sub-Category: Bookproduct
function Getsummaryline () {
$base = Parent::getsummaryline ();
$base. = ": Page cont-{$this->numpages})";
return $base;
}

We completed the "core" function for the Getsummaryline () method in the parent class shopproduct, followed by simply invoking the parent class's method in the subclass and then adding more data to the digest string, and the extension of the method was implemented.

I hope this article is helpful to everyone's PHP programming.

http://www.bkjia.com/PHPjc/957135.html www.bkjia.com true http://www.bkjia.com/PHPjc/957135.html techarticle PHP Implementation of the parent call to the parents of the constructor method and the method of overwriting, the parent of this article describes the implementation of the parent call to the parents of the method of constructing and overwriting. To share with you ...

