The three major characteristics of object-oriented objects: encapsulation, inheritance, and polymorphism. First, let’s briefly understand abstraction:
When we defined a class earlier, we actually extracted the common attributes and behaviors of a class of things. , forming a physical model (template), this method of studying the problem is called abstraction
1. Encapsulation
Encapsulation is to combine the extracted data with the data The operations are encapsulated together, the data is protected internally, and only authorized operations (methods) in other parts of the program can operate on the data.
php provides three access control modifiers
public means global, accessible inside this class, outside the class, and subclasses
protected means protected, only this class or subclasses can access
private means private and can only be accessed within this class
The above three modifiers can modify both methods and properties (variables). If the method does not have access modifiers, it defaults to public. Member properties must specify access modifiers. , there is also this way of writing var $name in PHP4, which means public attributes. This way of writing is not recommended.
Example:
Copy code The code is as follows:
class Person{
public $name;
protected $age;
private $salary;
function __construct($name,$age ,$salary){
$this->name=$name;
$this->age=$age;
$this->salary=$salary;
}
public function showinfo(){
//This means that all three modifiers can be used inside this class
echo $this->name."||".$this->age."| |".$this->salary;
}
}
$p1=new Person('Zhang San',20,3000);
//This is outside the class, so if you use The following methods will report errors when accessing age and salary.
// echo $p1->age; echo$p1->salary;
?>
Then what I want to do now is What to do when accessing protected and private elements and methods from outside? The usual approach is to access these variable formats through public functions:
public function setxxxx($val){
$this->xxxx=$val;
}
public function getxxxx(){
return $this-> >salary; //Extension: You can call some methods here, such as judging the user name, etc., and only give access if it is correct
}
You can use echo from the outside $p1->getsalary();
If To access protected and private, you can also use the following methods, but they are not recommended. Just understand them
__set() and __get()
__set() assign values to protected or private attributes
__set( $name,$val);
__get() gets the value of protected or private
__get($name);
For example:
Copy code
The code is as follows:
class testa{ protected $name;
//Use __set() to manage all attributes
public function __set($pro_name,$pro_val){
//$pro_name and $pro_val above can be customized
//$this->pro_name below is established and cannot be changed
$this->pro_name =$pro_val;
}
//Use __get() to get all attribute values
public function __get($pro_name){
if(isset($pro_name)){
return $this->pro_name;
} else {
return null;
}
}
}
$n1=new testa();
//Normal situation, Protected attributes cannot be accessed outside the class, but you can operate them using the above method
$n1->name='小三';
echo $n1->name;
? >
//You can understand the above code, but it is not recommended to use it
2. Inheritance
Let’s look at an example first:
Copy code
The code is as follows:
class Pupil{ public $name;
protected $age;
public function getinfo(){
echo $this->name.'||'.$this->age;
}
public function testing(){
echo 'this is pupil';
}
}
class Graduate{
public $name;
protected $age;
public function getinfo(){
echo $this-> name.'||'.$this->age;
}
public function testing(){
echo 'this is Graduate';
}
}
?> ;
As can be seen from the above example, when multiple classes have many common attributes and methods, the code reusability is not high and the code is redundant. Think about the processing method in CSS
Solution: Inherit
Copy code
The code is as follows:
class Students{
public $name;
public $age;
public function __construct($name,$age){
$this- >name=$name;
$this->age=$age;
}
public function showinfo(){
echo $this->name.'||'.$ this->age;
}
}
class Pupil extends Students{
function testing(){
echo 'Pupil '.$this->name.' is testing';
}
}
class Graduate extends Students{
function testing(){
echo 'Graduate '.$this->name.' is testing';
}
}
$stu1=new Pupil('张三',20);
$stu1->showinfo();
echo '
';
$stu1- >testing();
?>
As can be seen from the above, inheritance is a subclass (Subclass) extending the parent class to the public and protected in the parent class (BaseClass) The attributes and methods continue and cannot inherit private attributes and methods
Syntax structure:
class parent class name {}
class subclass name extends parent class name {}
Details:
1 , a subclass can only inherit one parent class (here refers to direct inheritance); if you want to inherit the attributes and methods of multiple classes, you can use multi-level inheritance
Example:
Copy the code The code is as follows:
class A{
public $name='AAA';
}
class B extends A{
public $age=30;
}
class C extends B{}
$p=new C();
echo $p->name;//here AAA will be output
?>
2. When creating a subclass object, the constructor of its parent class will not be automatically called by default
Example:
class A{
public function __construct(){
echo 'A';
}
}
class B extends A{
public function __construct(){
echo 'B ';
}
}
$b=new B();//The constructor in B will be output first. If there is no constructor in B, the
in A will be output. 3. If you need to access the methods of the parent class in a subclass (the modifiers of constructors and member methods are protected or private), you can use parent class::method name or parent::method name to complete [here parent and the previous premise] The self received are all lowercase, and an error is reported in uppercase]
class A{
public function test(){
echo 'a_test';
}
}
class B extends A{
public function __construct(){
//Both methods will work
A::test();
parent::test();
}
}
$b=new B();
5. If the method of a subclass (derived class) is exactly the same as the method of the parent class (public, protected), we call it method coverage or method override. Look at the polymorphism below
3. Polymorphism Example:
Copy the code The code is as follows:
class Animal{
public $name;
public $price;
function cry(){
echo 'i don't know' ;
}
}
class Dog extends Animal{
//Override, override
function cry(){
echo 'Wang Wang!';
Animal:: cry();//No errors will be reported here, and the cry() of the parent class can be executed correctly;
}
}
$dog1=new Dog();
$dog1->cry( );
?>
Summary:
1. When a parent class knows that all subclasses have a method, but the parent class is not sure how to write the method, you can let For a subclass to override its method, method overriding (rewriting) must require that the method name and number of parameters of the subclass are exactly the same
2. If the subclass wants to call a method of the parent class (protected/public), You can use parent class name::method name or parent::method name
3. When implementing method rewriting, the access modifiers can be different, but the access rights of the subclass method must be greater than or equal to the access of the parent class method. Permissions (that is, the access permissions of the parent class method cannot be reduced)
For example, if the parent class public function cry(){} and the subclass protected function cry(){} will report an error
But the access permissions of the subclass can be enlarged, such as :
Parent class private function cry(){} subclass protected function cry(){} can execute correctly
Extension:
Method overload (overload)
Basic concept: The function name is the same, but The number of parameters or the type of parameters are different. When the same function is called, different functions can be distinguished
Although overloading is also supported in PHP5, it is still very different from other languages. Multiple functions cannot be defined in PHP. The function of the same name
PHP5 provides powerful "magic" functions. Using these magic functions, we can overload functions.
Here we have to go to __call, when an object calls a method, and the If the method does not exist, the program will automatically call __call
[Officially not recommended]
There are the following magic constants in PHP: __LINE__ __FILE__ __DIR__ __FUNCTION__ __CLASS__ etc.
Example:
Copy code The code is as follows:
class A{
function test1($p){
echo 'test1
';
}
function test2($ p){
echo 'test2
';
}
function __call($method,$p){
//Here $p is an array, and the above two variable names can Customized
if($method == 'test'){
if(count($p)==1){
$this->test1($p);
} else if(count($p)==2){
$this->test2($p);
}
}
}
}
$a=new A ();
$a->test(5);
$a->test(3,5);
?>
http://www.bkjia.com/PHPjc/325493.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/325493.htmlTechArticleThe three major characteristics of object-oriented objects: encapsulation, inheritance, and polymorphism. First, let’s briefly understand abstraction: When we defined a class earlier, we actually combined the attributes common to a class of things...
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
