PHP study notes Application of one of the three major object-oriented features in PHP [encapsulation]_PHP tutorial

Copy code The code is as follows:

/*
* Encapsulation: one of the three major characteristics of object-oriented
*
* 1. It is to combine the members (properties, methods) of the object into an independent and identical unit, and hide the internal details of the object as much as possible
* Access permission modifier public protected private
* private: private, members modified with this keyword can only be accessed within the object ( Only accessed with $this)
*
* Attributes can be encapsulated:
* As long as a variable needs to be used in multiple methods, declare this variable as a member attribute, which can be directly used in all objects in this object. The
*
* member attributes used in the method are equivalent to the global variables in this object. The
*
* member attributes will be used in the method. The change of the member attribute value is actually changing the execution of the method. Behavior, that is, changing the function of the object
*
* If the value of the member attribute is abnormal, the function executed by the method will be abnormal
*
* Function: No need to change or change outside the object Read its value
* 1. Encapsulate
* and provide a public method (you can control the assignment and value acquisition of object member attributes through the method)
*
*
* Methods can also be encapsulated
*
* Function:
* 1. Use private modification so that it can only be used internally
*
* 2. There are 100 methods in a class, encapsulated 95 (methods that serve the other 5), only 5 methods can use
*
* 100 member attributes, all allow values ​​to be obtained, and the values ​​cannot be changed; or the values ​​can only be changed, but the values ​​cannot be obtained. //In this case, it is more convenient to use the following methods
* Magic methods related to encapsulation:
*
* __set(); // Automatically called when directly setting the [private] member attribute value The method
* __get();//is the method automatically called when directly obtaining the [private] member attribute value
* __isset();//is directly using isset() to check whether the private attribute in the object is When exists, this method is automatically called
* __unset();//This method is automatically called when unset() is used directly to delete private attributes in the object
*
*
*
*
*
*
*
*/
class Person{
//x encapsulates member attributes and does not need to be changed outside the object
private $name;
private $age;
private $sex;
private __unset($proName){
unset($this->$proName);
}
//Directly view the private properties in the object When it exists, this method is automatically called
//Usage of __isset($proName), $proName represents the attribute name
private function __isset($proName){
return isset($this->$proName );//isset() returns whether there is
}
function __construct($name,$age,$sex){
$this->name=$name;
$this-> ;age=$age;
$this->sex=$sex;
}
//When obtaining private member attributes, this method is automatically called
private function __get($proName)
{
//Control the value obtained
if($proName=="age"){
if($this-age>40)
return $this->age -10;
}
return $this->$proName;
}
//When setting private member properties, this method is automatically called
private function __set($proName, $proValue){
//$proName represents the member attribute name, $proValue represents the member attribute value
//Control the setting range
if($proName=="age"){
if($ proValue > 100 || $proValue<0)
return;
}
$this->$proName=$proValue;
}
//Provide public methods to set member properties The value of
function setAge($age){
//Control the age range and increase security
if($age > 100 || $age < 0 )
return;
$this->age=$age;
}
//Provide public methods to get the value of member attributes
function getAge(){
//Control the range of getting age
if ($this->age < 30)
return $this->age;
else if($this->age<40)
return $this->age-5;
else if($this->age<50)
return $this->age;
else
return $this->age-15;
Provide public methods to }
function say(){
echo "My name: {$this->name}, my age: {$this->age}, my last name: {$this-> ;sex}
";
//Access the encapsulated run() method
$this-run();
}
private function run(){
echo ' 111111111111
'
}
function eat(){
}
//Destruction method
function __destruct(){
}
}
$p1 =new Person("zhangsan",25,"male");
$p2=new Person;
$p3=new Person;
//$p1->age=-50;// Because the age can be accessed from the outside at will, the member attributes are encapsulated for security.
$p1->setAge(30);//Set the member attribute value through the method
$p1->getAge();//Get the member attribute value through the method
// By adding the magic method __set($proName,$proValue) __get($proName), you can directly call member properties
$p1->say();//You can call
$p1-> ;run();//Private methods cannot be called directly
//Delete the name in $p1
unset($p1->name);
//Determine whether the name exists
if (isset($p1->name)){
echo "Exists
";
}else{
echo "There is no such member
";
}
?>

Author: Codename Aurora
Source: http://zizhuyuan.cnblogs.com

http://www.bkjia.com/PHPjc/323518.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/323518.htmlTechArticleCopy the code as follows: ?php /* * Encapsulation: one of the three major characteristics of object-oriented * * 1. It is to combine the members (properties, methods) of the object into an independent and identical unit and hide it as much as possible...