Comparison of two versions of PHP object-oriented method overloading

Multiple functions use the same name, but the parameter list, that is, the number of parameters or (and) data type, can be different. When calling, although the method name is the same, the corresponding function can be automatically called according to the parameter list.
PHP4 only implements some simple object-oriented functions, but the support for objects will be much more powerful in PHP5.
For polymorphic implementation, PHP4 only supports override but not overload. But we can use some tricks to "simulate" the implementation of overloading.
Although PHP5 can support overwriting and overloading, the specific implementation of overloading is still quite different from other languages.
1. "Simulating" overloading in PHP4

Try the following code:

//Choose to execute different methods according to the number of parameters (simulating "overloading" in PHP4 (a type of polymorphism) )

class Myclass
{
function Myclass()
{
$method = "method" . func_num_args();
$this->$method();
}

function method1($x)
{
echo "method1";
}

function method2($x, $y)
{
echo 'method2';
}
}

//Using this class is transparent to users through additional processing in the class of:
$obj1 = new Myclass('A'); //method1 will be called
$obj2 = new Myclass('B','C'); //method2 will be called
?>

In the above code, By using the func_num_args() function in the constructor to get the number of parameters, the method1 or method2 method can be automatically executed. We can improve the above example by combining the functions func_get_arg(i) and func_get_args() and use it in PHP5. Overloading

First look at the following example:

Copy the code as follows:

class Myclass
{
public $attriable;
public $one = "this is one";
public $two = "this is two";

function __construct()

{

}

function one($one)

{

$this->one=$one;
$this->attriable = $this->one;
}

function one($one, $two)

{

$this->one=$one;
$this->two=$two;
$this->attriable = $this-> one . $this->two;
}

function display()

{

echo $this->attriable;
}
}

$one = "this is my class";

$two = "Im the best";

$myclass = new myclass();
$myclass->one($one);
$myclass->display();

$myclass->one($one, $two) ;

$myclass->display();

//The approach in this example is incorrect in PHP!

?>

People who have used C++, Java, and C# overloading will be accustomed to writing the PHP code for the above overloading implementation. But this is not true in PHP5. PHP5 is not an imitation of the aforementioned languages, but has its own set of methods for implementing method overloading (whether it is good or bad will not be discussed here). Although the classes of PHP5 are much more powerful than those of PHP4, the issue of "overloading" has not been "improved" as we expected. "Overloading" can be achieved through different parameter types in "strongly" typed languages, such as C++, Java, C#, etc. In languages ​​where "fixed parameters" are passed, it can also be passed by the number of parameters, such as Java, but PHP is a weakly typed language, so there will be no "overloading" like the above.

In PHP5, overloading can be performed through several special methods __get, __set, and __call. PHP will call these methods when the Zend engine tries to access a member and cannot find it.

In the following example, __get and __set replace all accesses to the attribute variable array. If necessary, you can also implement any type of filtering you want. For example, a script can disable setting property values, start with a certain prefix, or include a certain type of value. The __call method illustrates how you can call an undefined method. When you call an undefined method, the method name and the parameters received by the method will be passed to the __call method, and PHP returns the value of __call to the undefined method.

The code is as follows:

class Overloader
{
private $properties = array();

function __get($property_name)

{

if(isset($this->properties[$property_name] ))
{
return($this->properties[$property_name]);
}
else
{
return(NULL);
}
}

function __set($property_name, $value)

{

$ this->properties[$property_name] = $value;
}

public function __call($method, $p)
{
print("Invoking $method()
n");
//print("Arguments: ");
//print_r($args);
if($method == 'display')
{
if(is_object($p[0]))
$this->displayObject($p[0]);
else
if(is_array($p[ 0]))
$this->displayArray($p[0]);
else
$this->displayScalar($p[0]);
}
}

public function displayObject($p)
{
echo ("What you passed in is an object, the content is as follows:
");
print_r($p);
echo "

---

";
}

public function displayArray($p)
{
echo ("What you passed in is an array, the content is as follows:
");
print_r($p);
echo "

---

";
}

public function displayScalar($p)
{
echo ("What you passed in is a separate variable with the following content:
" . $p);
echo "

---

";
}
}

$o = new Overloader();

//Call __set() to assign a value to a non-existent attribute variable
$o->dynaProp = "Dynamic Content";

//Call __get()
print($o->dynaProp . "< ;br>n");

//Call __call()
//$o->dynaMethod("Leon", "Zeev");

$o->display(array(1,2, 3));
$o->display('Cat');
?>

In the above code, the display() method is called, and the corresponding code segment in the class can be called according to the type and number of parameters. , thus realizing the overloading of object methods.

Thank you for reading. If you want more related content, please pay attention to the PHP Chinese website (m.sbmmt.com)!