Sharing on how to use inheritance during PHP development

Inheritance
Usually required are classes that have the same variables and functions as other existing classes. In fact, it would be a good exercise to define a common class that is used in all projects, and to continuously enrich this class to adapt to each specific project. To make this easier, classes can extend from other classes. An extended or derived class owns all the variables and functions of its base class (this is called "inheritance", except no one dies), and includes all the parts defined in the derived class. The elements in the class cannot be reduced, that is, any existing functions or variables cannot be unregistered. An extension class always depends on a single base class, that is, multiple inheritance is not supported. Use the keyword "extends" to extend a class.
Copy code The code is as follows:
class test {
public function __construct() {
}
public function name() {
$this->xname('John');
}
private function showName ($name) {
echo 'my name in test is '.$name;
}
}
class extendTest extends test {
public function __construct() {
parent::__construct();
}
private function showName( $name) {
echo 'my name in extendTest is '.$name;
}
}
$test = new extendTest();
$test->name();
?>

The above example defines A class named Named_Cart that has all the variables and functions of the Cart class, plus the additional variable $owner and an additional function set_owner(). Now, a named shopping cart is created in the normal way, and the owner of the shopping cart can be set and retrieved. The normal shopping cart class functions can still be used in the named shopping cart class:
$ncart = new Named_Cart; // Create a new named shopping cart
$ncart->set_owner(" kris"); // Name the shopping cart
print $ncart->owner; // Output the name of the shopping cart owner
$ncart->add_item("10", 1); // (from the shopping cart Functions inherited from the class)
?>
This can also be called the "father-child" relationship. Create a class, the parent class, and use extends to create a new class based on the parent class: the child class. You can even use this new subclass to create another class based on this subclass.
Note:
A class can only be used after being defined! If you need class Named_Cart to inherit class Cart, you must first define the Cart class. If you need to create another Yellow_named_cart class based on the Named_Cart class, you must first define the Named_Cart class. To put it simply: the order of class definitions is very important.
Copy the code The code is as follows:
class Person{
protected $name;//protected permissions can be accessed in subclasses, but cannot be accessed externally
protected $age;
protected $sex;
function __construct($name,$age ,$sex){
$this->name=$name;//When using this, even if name is not declared, it will be declared again
$this->age=$age;
$this-> sex=$sex;
echo "###############";
}
public function say(){
echo "My name: {$this->name}, My age {$this->age}:, My gender: {$this->sex}
";
}
protected function eat(){
echo "wwwwwwwwwwwwwwwwwwwww
" ;
}
function run(){
}
protected $name;//Protected permissions can be accessed in subclasses, but not externally
protected $age;
protected $sex;
}
//Inherited
class Student extends Person{
var $school;
function __construct($name,$age,$sex,$school){
parent::__construct();//Call the constructor method of the parent class
$this->school= $school;
}
//Overload the say() method and expand
protected function say(){//The parent class uses public, the permissions of the subclass cannot be lower than the parent class, and can have the same permissions as the parent class
/ /Person::say();//Call the say() method of the parent class
parent::say();//Call the say() method of the parent class, parent represents the parent class name, and can also be used when the parent class name changes transfer.
echo "My school {$this->school}
";//www.php.cn
}
function study(){
echo "{$this->name} in Study
";
}
}
$s=new Student("zhangsan",23,"male");
$s->say();
$s->study() ;

* 1. One of the three major characteristics of object-oriented
*
* 2. Openness and scalability
*
* 3. Increase the reusability of code
*
* 4. Improve the maintainability of software
*
* 5. Inheritance is to use subclasses to “extend” parent classes
*
* C++ belongs to multiple inheritance, the same class can have multiple parent classes
*
* PHP and JAVA belong to single inheritance, the same class can only have one parent class
*
* Whether it is multiple inheritance or single inheritance, both can have Multiple subclasses
*
* As long as you have members that can be shared when designing two classes, use the shared content as a base class alone
*
* 1. Application of class inheritance
*
* 1. Declare a subclass and use the extends keyword to inherit (extend) a parent class
*
* 2. The subclass can inherit all content from the parent class, including member attribute methods, construction methods..., in Can be used in subclasses
*
* 2. Access type control
*
* Although subclasses can inherit everything from parent classes, private members can only be used in this class, not in subclasses. When using
*
* encapsulation, you can not only make the inside of your own class accessible, but also make it available to subclasses, but the outside of the class cannot be used. Just set the permission to protected
*
*
*
* 3. Subclass Overloading methods of the parent class
*
* 1. The subclass can declare the same method name as the parent class, that is, the subclass overrides the method of the parent class with the same name
*
* 2. The method of the subclass has the same name as the parent class Extension of method
*
* 3. Call the overridden method in the parent class in the subclass
* Use parent class name::method name() parent::method name()
*
* 4. In the subclass Write a constructor. If there is a constructor in the parent class, be sure to call the overridden constructor in the parent class once.
*
* Note: The overloaded methods in the subclass cannot have lower access rights than those in the parent class (subclass Permissions can be enlarged, but permissions cannot be reduced)