Detailed explanation of php class encapsulation and inheritance usage

Class is an important concept in Object-oriented, and encapsulation and inheritance are important features of object-oriented. In this article, we will focus on the two characteristics of encapsulation and inheritance, and give some examples for your reference.

Encapsulation

Encapsulate member methods and member properties into classes, hiding properties and methods implementation details, By limiting the access rights of class members such as public, protected, private, etc., the data is protected internally and can only be operated through authorized member methods, and members are encapsulated as much as possible.

public: Methods or properties can be accessed in any scope and are by default. If no access modifier is specified for a property or method, it will be public.
protected: This class and subclasses can be accessed, but external objects cannot be called.
private: can only be accessed in this class, and cannot be called by subclasses or external objects. Methods or attributes marked private can be redefined in inherited classes, and each class can only see its own defined private methods.

In terms of scope, these three modifiers should be sorted from large to small like this: public→protected→private. The reason why it is said to be in scope is because the class encapsulates some properties and methods. , this encapsulation determines the "visibility" of the data, so that we cannot modify the defined properties and methods at will outside the class but can only call them. This is the benefit of encapsulation, and it also improves security.
We give code examples:

 class myClass{ 
  public $public="Public";    //public属性
  protected $protected="Protected"; //protected属性
  private $private="Private";   //private 属性
  function say_Hello() {    //public属性 
  //只是举例说明，自行添加内容
  } 
 
 $obj=new myClass(); 
 echo $obj->public; 
 //echo $obj->protected; 
 //echo $obj->private;

By running the above example we get a "Public", but when you remove the comment of //echo $obj->private; , you will get the following error:

Fatal error: Cannot access protected property myClass::$protected in E:apachehtdocsexamplefile.php on line 13.

You can see that we cannot access the attribute definitions of a class at will. We don't know "outside" what members are in this class, because these members may not be available to other classes. Of course, if we must access or modify attributes defined as "private", we can also use the system methods provided by PHP: _get() and _set().

Inheritance

You can make a class inherit and have the member properties and methods of another existing class. The inherited class is called the parent class or base class. Inheritance Class is a subclass. The inheritance relationship is implemented through the extends keyword. Generally speaking, to have inheritance, you must have a "root". For this "root", you may imagine that if you give birth to a son or daughter in the future, they will get some "things (properties and methods)" from you, so that your " Descendants" are those who possess some of the characteristics of you (the source).

Generate the "root" class (parent class or base class)
Syntax: class father{
}

Generate "descendants" ( Subclass)
Syntax: class son extends father{
}

PHP extends class inheritance example code:

class father{ 
 protected $name; 
 function construct($name){  //构造函数 
  $this->name=$name; 
 } 
 
 function work(){ 
  echo "{$this->name}我在工作;
 } 
 function destruct(){}  //析构函数
} 
 
class son extends father{  //继承父类
 function play(){ 
  echo "{$this->name}我在玩游戏;
 }  
} 
 
 $my_father=new father(“爸爸”);  //创建父类对象
 $my_father->work(); 

 $my_son=new son(“儿子”); 
 $my_son->work(); 
 $my_son->play();

Analysis: In the parent class father, we define Common properties and methods, and then define subclasses. You may find that there are no constructors and destructors in the subclass, because the subclass inherits all the methods of the parent class, so you can call $my_son->work(); This is the PHP class inherit. Also note: PHP cannot have multi-level inheritance, such as: class A extends B extends C. Such inheritance is invalid in PHP. There is only single inheritance in PHP, not multiple inheritance. Other methods are needed to "implement" multiple inheritance in disguise.

The above is the detailed content of Detailed explanation of php class encapsulation and inheritance usage. For more information, please follow other related articles on the PHP Chinese website!