Comparison of two versions of PHP object-oriented method overloading_PHP tutorial

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 PHP5’s support for objects will be much more powerful in the future.

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 quite different from other languages.

1, "simulate" overloading in PHP4

Try the following code:

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

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

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

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

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

In the above code, by using the func_num_args() function in the constructor to get the number of parameters, we can automatically execute the method1 or method2 method. We can combine the functions func_get_arg(i) and. func_get_args() Improve the above example by using overloaded

in PHP5:

Copy Code The code is 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 method in this example is This is incorrect in PHP!
?>


People who have used C++, Java, and C# overloading are 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.

Overloading in PHP5 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.

Copy code 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 ("你传入的是个对象，内容如下:
");
print_r($p);
echo "

---

";
}

public function displayArray($p)
{
echo ("你传入的是个数组，内容如下:
");
print_r($p);
echo "

---

";
}

public function displayScalar($p)
{
echo ("你传入的是个单独变量，内容如下:
" . $p);
echo "

---

";
}
}

$o = new Overloader();

//调用 __set() 给一个不存在的属性变量赋值
$o->dynaProp = "Dynamic Content";

//调用 __get()
print($o->dynaProp . "
n");

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

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

以上代码中，调用了 display() 方法，可以根据参数的类型和个数调用类中的对应的代码段，从而实现了对象方法的重载。

http://www.bkjia.com/PHPjc/319404.htmlwww.bkjia.comtruehttp://www.bkjia.com/PHPjc/319404.htmlTechArticle多个函数用同一个名字，但参数表，即参数的个数或(和)数据类型可以不同，调用的时候，虽然方法名字相同，但根据参数表可以自动调用对...