Detailed explanation of encapsulation and inheritance of PHP classes, detailed explanation of PHP encapsulation_PHP tutorial

Detailed explanation of encapsulation and inheritance of PHP classes, detailed explanation of PHP encapsulation

Encapsulation

Encapsulate member methods and member attributes into classes, hide the details of attribute and method implementation, and limit the access rights of class members through public, protected, private, etc. The data is protected internally and can only be accessed through authorized member methods. It can be operated and the members are encapsulated as much as possible.

public: A method or property can be accessed in any scope and is 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.

These three modifiers should be sorted from large to small in terms of scope: public→protected→private. The reason why it is said to be in scope is because the class encapsulates some attributes and methods. This encapsulation This 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 properties defined as "private", we can also use the system methods provided by PHP: _get() and _set().

Inherit

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, and the inherited 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 "root" class (parent class or base class)
Syntax: class father{
}

Produce "descendants" (subclasses)
Syntax: class son extends father{
}

PHP extends class inheritance sample 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 general attributes and methods, and then define the subclass. 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 inheritance of the PHP class. 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 learning content about encapsulation and inheritance of PHP classes. I hope it will be helpful to everyone's learning.

http://www.bkjia.com/PHPjc/1058166.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/1058166.htmlTechArticleDetailed explanation of encapsulation and inheritance of PHP classes, detailed explanation of PHP encapsulation. Encapsulation encapsulates member methods and member attributes into classes, hiding The details of attribute and method implementation are limited by public, protected, private, etc...