Detailed explanation of overloading in PHP

Overloading in PHP is different from other object-oriented (C#, Java) languages. For example, overloading in C# has the same method name, but different formal parameter lists (i.e., the number of formal parameters, A different type and arrangement) function will determine which method to call based on the formal parameter list when calling.

Overloading in PHP is for the processing of inaccessible members of the current object (not defined or defined but inaccessible):

<?php
	Class Student{
		private $_age;
	}
	$o1=new Student();
	$o1->_name="Li";
	var_dump($o1);
	echo "<br/>";
	$o1->_age=24;
	var_dump($o1);
 ?>

We can see from this result: when accessing the non-existent member $_name, the member will be put into the object as a shared attribute. When it comes to access rights issues, an error will be reported.

For this situation, there are some magic methods for attribute overloading in php:

Attribute overloading

1.__set($name,$value): When calling When a attribute is inaccessible (does not exist/access is restricted), the system will automatically call the __set() function in the corresponding class. $name represents the called attribute name, and $value represents the value passed in during the operation.

If the attribute does not exist:

<?php
	Class Student{
		private $_age;
		function __set($name,$value){
			
		}
	}
	$o1=new Student();
	$o1->_name="Li";
	var_dump($o1);

Here when we make some changes to the above example: In the Student class Add a __set() method to the __set() method. When the code $o1->_name="Li"; is executed, the __set() method will be automatically called. Since there is no code in it, it is impossible to achieve the same assignment as the default situation, so there is only one private property $_age in the displayed $o1 object;

You can also write this code in the __set() method:

    function __set($name,$value){
$this->$name=$value;
}

The result at this time is

If the attribute exists, but it is inaccessible:

<?php
header("Content-Type:text/html;charset=utf-8");
	Class Student{
		private $_age;
		function __set($name,$value){
		//进入该函数表示$name 这个属性不可访问。
			if(property_exists($this,$name)){
				//property_exists()函数判断当前对象（$this）中是否存在$name属性。
				trigger_error("属性不可访问！",E_USER_ERROR);
			}else{
				
			}
		}
	}
	$o1=new Student();
	$o1->_age=2;
	var_dump($o1);

2.__get(): Will be triggered when accessing inaccessible members:

<?php
header("Content-Type:text/html;charset=utf-8");
	Class Student{
		private $_age=23;
		function __get($name){
		//进入该函数表示$name 这个属性不可访问。
			return $this->$name;
		}
	}
	$o1=new Student();
	echo $o1->_age;
	echo "<br/>";
	var_dump($o1);

3.__unset(): This function is triggered when a variable is deleted.

Its specific application scenario: We all know the unset() function, which deletes a certain variable. This can also be used in objects. For example, in our example above, if $_age is public, then you can use unset($o1->_age); However, $_age here is a private attribute, which cannot be accessed using unset() at this time.

<?php
header("Content-Type:text/html;charset=utf-8");
	Class Student{
		private $_age=23;
	}
	$o1=new Student();
	unset($o1->_age);

This requires the __unset() magic method to implement the deletion of attributes in the class:

<?php
header("Content-Type:text/html;charset=utf-8");
	Class Student{
		private $_age=23;
		function __get($name){
			return $this->$name;//正常应该有判断语句，这里省略了。
		}
		function __unset($name){
			unset($this->$name);
		}
	}
	$o1=new Student();
	echo $o1->_age;
	unset($o1->_age);
	echo $o1->_age;

The specific application is similar to the above __set() and __get(), that is, when you unset (variable name);, the __unset() method will be automatically called, and the method body can be defined by yourself.

4.__isset(): Mainly used to determine whether attributes exist, the same as __unset(). When the outside wants to determine whether there is an attribute, the private variable cannot be accessed using the isset() function. In this case, the __isset() method can be used to define it.

Overloaded method

The conditions for method overloading and attribute overloading are the same: when calling a method that does not exist or is inaccessible, the __call() and Static__callStatic() methods will be called.

Call a method that does not exist by default in the system:

<?php
header("Content-Type:text/html;charset=utf-8");
	Class Student{
		public static $a=1;
		private $_age=23;
	}
	$o1=new Student();
	$o1->getName();//当调用本不存在的方法时。

A serious error will occur in the system.

__call(): The magic method used when calling using an object

<?php
header("Content-Type:text/html;charset=utf-8");
	Class Student{
		public static $a=1;
		private $_age=23;
		function __call($name,$arr){
			//$name表示传入的方法名，$arr表示传入的方法列表（是一个数组）。
			trigger_error("不存在该函数",E_USER_NOTICE);//直接报错
			//也可以在此重写函数。
		}
	}
	$o1=new Student();
	$o1->getName();//当调用本不存在的方法时。

##Static__callStatic(): Using a class calling method, that is, calling an object that does not exist This magic method can be used when using static methods.

Related recommendations:

Introduction to overloading in PHP

Detailed explanation of function overloading in JavaScript

Detailed explanation of examples of overloading and magic methods in php

The above is the detailed content of Detailed explanation of overloading in PHP. For more information, please follow other related articles on the PHP Chinese website!