PHP object-oriented guide (5) Encapsulation_PHP tutorial-PHP Tutorial-php.cn

9. Encapsulation
Encapsulation is one of the three major characteristics of object-oriented programming. Encapsulation is to combine the properties and services of an object into an
independent and identical unit, and try to Concealing the internal details of an object has two meanings: 1. Combining all the attributes and all services of the object to form an indivisible independent unit (i.e. object). 2. Information hiding, that is, hiding the internal details of the object as much as possible, forming a boundary [or forming a barrier] to the outside world, and retaining only a limited external interface to connect it with the outside world. The reflection of the principle of
encapsulation in software is that it requires that parts other than the object cannot access the internal data
(attributes) of the object at will, thereby effectively avoiding the "cross-infection" of external errors and making it Software errors can be localized, greatly reducing the difficulty of error detection and troubleshooting.
Let’s use an example to illustrate. Suppose a person’s object has attributes such as age and salary. Such personal privacy attributes
are not accessible to other people. If you don’t use encapsulation, Then others can get it if they want to know, but
if you encapsulate it, others will have no way to obtain the encapsulated attributes. Unless you tell it yourself, there is no way for others to
get it.
For another example , every personal computer has a password. If you don’t want others to log in at will, copy and
paste it into your computer. Also, for objects like people, the attributes of height and age can only be increased by oneself, and cannot be assigned values arbitrarily
by others, etc.
Use the private keyword to encapsulate properties and methods:
Original members:
var $name; //The name of the declarant
var $sex; //The gender of the declarant
var $age; //Declare the person’s age
function run(){… … .}
Change to encapsulated form:
private $name; //Use the private keyword for the person’s name Encapsulate
private $sex; //Encapsulate the person’s gender using the private keyword
private $age; //Encapsulate the person’s age using the private keyword
private function run(){… … } //Use the private keyword to encapsulate a person’s walking method
Note: As long as there are other keywords in front of the member attributes, the original keyword "var" must be removed.
You can encapsulate human members (member attributes and member methods) through private. The members in the package cannot
be directly accessed from outside the class, only the object itself can access it; the following code will generate an error:
Code snippet

Copy code

The code is as follows: class Person{ //The following are the member attributes of the person

private $name; //The name of the person is encapsulated in private

private $sex; //A person’s gender, encapsulated by private
private $age; //Age of a person, encapsulated by private
//How this person can speak
function say(){ 
echo "My name is: ".$this->name." Gender: ".$this->sex." My age is: ".$this->age. "
"; 
} 
//The method by which this person can walk is encapsulated privately 
private function run(){ 
echo "This person is walking"; 
} 
} 
//Instantiate a person’s instance object
$p1=new Person(); 
//Trying to assign a value to a private attribute, an error will occur
$ p1->name="Zhang San"; 
$p1->sex="Male"; 
$p1->age=20; 
//Trying to print private attributes, the result The error will occur 
echo $p1->name.”
”; 
echo $p1->sex.”
”; 
echo $p1->age. "
" 
//When trying to print private member methods, an error will occur 
$p1->run(); 

 
The output result is: 
Fatal error: Cannot access private property Person::$name 
Fatal error: Cannot access private property Person::$sex 

Fatal error: Cannot access private property Person::$age
Fatal error: Cannot access private property Person::$name
Fatal error: Call to private method Person::run() from context ''
As you can see from the above example, private members cannot be accessed externally because Private members can only be accessed within this object
. For example, if the $p1 object wants to share its private attributes, it accesses the private attributes in the say() method. This is OK. (No access control is added. The default is public and can be accessed from anywhere.)
Code snippet

Copy code

The code is as follows :

//This person can speak, speak his own private attributes, and you can also access private methods herefunction say(){ echo "My name is : ".$this->name." Gender: ".$this->sex." My age is: ".$this->age."
"; //In Private methods can also be accessed here

//$this->run();

}

Because the member method say() is public, we can call the say() method outside the class. Change the above
code;
Code snippet

Copy code The code is as follows:

 
class Person{ 
//The following are the member attributes of the person
private $name; //The name of the person, Encapsulated by private 
private $sex; //The gender of the person is encapsulated by private
private $age; //The age of the person is encapsulated by private
//Define a constructor The parameters are assigned to the private attributes name $name, gender $sex and age $age 
function __construct($name, $sex, $age){ 
//The $name passed in through the constructor method is assigned to the private member The attribute $this->name is assigned an initial value 
$this->name=$name; 
//The $sex passed in through the construction method is assigned an initial value to the private member attribute $this->sex Value
$this->sex=$sex; 
//The $age passed in through the constructor is assigned an initial value to the private member property $this->age 
$this->age =$age; 
} 
//The way this person can speak, speak his own private properties, you can also access the private methods here 
function say(){ 
echo "My name Name: ".$this->name." Gender: ".$this->sex." My age is: ".$this->age."
"; 
} 
} 
//Create three objects $p1, p2, $p3 through the construction method, and pass in three different actual parameters: name, gender and age 
$p1=new Person("Zhang San ","Male", 20); 
$p2=new Person("李思","Female", 30); 
$p3=new Person("王五","Male", 40) ; 
//The following accesses the speaking method in the $p1 object
$p1->say(); 
//The following accesses the speaking method in the $p2 object
$p2->say (); 
//The following accesses the speaking method in the $p3 object
$p3->say(); 

The output result is:
My name is: Zhang San Gender: Male My age is: 20
My name is: Li Si Gender: Female My age is: 30
My name is: Wang Wu Gender: Male My age is: 40
Because the constructor is the default public method (do not set the constructor to be private), it can be accessed from outside the class, so you can use the constructor to create objects. In addition, the constructor is also a function inside the class. , so you can use the construction method to assign initial values to private properties. The Say() method is public by default, so it can also be accessed from the outside and says
its own private attributes.
We can see from the above example that private members can only be used inside the class and cannot be directly
accessed by outside the class. However, they are accessible within the class, so sometimes We need to assign values to private properties and read them out
outside the class, that is, to provide some accessible interfaces outside the class. In the above example, the construction method is a form of assignment
, but the construction The method only assigns value when creating the object. If we already have an existing object and want to assign a value to this existing object, at this time, if you also use the constructor method to pass value, then create A
new object is created, which is not the existing object. Therefore, we need to make some
interfaces for private attributes that can be accessed externally. The purpose is to change and access the value of the attributes when the object exists. However, it should be noted that only external
needs to be accessed. This is done only for the properties that have been changed. Properties that do not want to be accessed by the outside do not have such an interface. In this way, the purpose of encapsulation can be achieved. All functions are completed by the object itself, providing as few operations as possible to the outside world.
If you provide an interface outside the class, you can provide setting methods and get methods for private properties outside the class to operate private
properties. For example:
Code snippet

Copy code

The code is as follows: prvate $age; //Private attribute agefunction setAge($age) {

//Provided externally A public method for setting age

if($age<0 || $age>130) //When assigning values to attributes, in order to avoid illegal values are set to the attribute
return;
$this-> ;age=$age;
}
function getAge(){ //Provide a public method for obtaining age externally
return($this->age);
}

The above method is to set and get the value for a member attribute. Of course, you can also use the same method for each attribute to
assign and get the value to complete the access work outside the class.