Explication détaillée des différences entre les deux versions surchargées en PHP

"Surcharge" est une implémentation du polymorphisme d'une classe. La surcharge de fonctions signifie qu'un identifiant est utilisé comme plusieurs noms de fonctions, et ces fonctions portant le même nom peuvent être distinguées par le nombre de paramètres ou de types de paramètres de la fonction, afin qu'aucune confusion ne se produise lors de l'appel. Le principal avantage est que vous n'avez pas besoin d'écrire plusieurs fonctions pour différents types de paramètres ou nombre de paramètres.

Plusieurs fonctions utilisent le même nom, mais la liste des paramètres, c'est-à-dire le nombre de paramètres ou (et) le

type de données peut être différent lors de l'appel, bien que le nom de la méthode soit le même. Idem, la liste des paramètres est différente selon les paramètres. La table peut appeler automatiquement la fonction correspondante.
PHP4 n'implémente que certaines des fonctions simples de
orienté objet, mais le support des objets sera beaucoup plus puissant en PHP5.
Pour une implémentation polymorphe, PHP4 ne prend en charge que le remplacement mais pas la surcharge. Mais on peut utiliser quelques astuces pour « simuler » la mise en œuvre d’une surcharge.

Bien que PHP5 puisse prendre en charge l'écrasement et la surcharge, l'implémentation spécifique de la surcharge est assez différente des autres langages.

1, "simuler" la surcharge en PHP4

Essayez le code suivant :

<?php 
//根据参数个数选择执行不同的方法(在 PHP4 中模拟"重载"(多态的一种) 
class Myclass 
{ 
function Myclass() 
{ 
$method = "method" . func_num_args(); 
$this->$method(); 
} 
function method1($x) 
{ 
echo "method1"; 
} 
function method2($x, $y) 
{ 
echo &#39;method2&#39;; 
} 
} 
//通过在类中的额外的处理，使用这个类对用户是透明的： 
$obj1 = new Myclass(&#39;A&#39;); //将调用 method1 
$obj2 = new Myclass(&#39;B&#39;,&#39;C&#39;); //将调用 method2 
?>

Dans le code ci-dessus, en utilisant le

constructeur< Utilisez la fonction func_num_args() dans 🎜> pour obtenir le nombre de paramètres et exécuter automatiquement la méthode method1 ou method2. Nous pouvons améliorer l'exemple ci-dessus en combinant les fonctions func_get_arg(i) et func_get_args(). 2, utilisez la surcharge en PHP5

Regardez d'abord les exemples suivants :

<?php 
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(); 
//本例的做法，在 PHP 中是不正确的！ 
?>

Ai utilisé la surcharge en C++, Java, C# People sont habitués à écrire du code PHP qui implémente la surcharge ci-dessus. Mais ce n'est pas vrai en PHP5. PHP5 n'est pas une imitation des langages susmentionnés, mais possède son propre ensemble de méthodes pour implémenter la

surcharge de méthodes
(que ce soit bon ou mauvais ne sera pas discuté ici). Bien que les classes de PHP5 soient bien plus puissantes que celles de PHP4, la problématique de la « surcharge » n’a pas été « améliorée » comme on l’espérait. La « surcharge » peut être obtenue grâce à différents types de paramètres dans des langages « fortement » typés, tels que C++, Java, C#, etc. Dans les langages où des "paramètres fixes" sont transmis, il peut également être transmis par le nombre de paramètres, comme Java, mais PHP est un langage faiblement typé, il n'y aura donc pas de "surcharge" comme ci-dessus. La surcharge en PHP5 peut être effectuée via plusieurs méthodes spéciales : get, set et call. PHP appellera ces méthodes lorsque le moteur Zend essaiera d'accéder à un membre et ne pourra pas le trouver.

Dans l'exemple suivant, get et set remplacent tous les accès au tableau de variables d'attribut. Si nécessaire, vous pouvez également mettre en œuvre tout type de filtrage souhaité. Par exemple, un script peut désactiver la définition des valeurs de propriété, commencer par un certain préfixe ou inclure un certain type de valeur. La méthode d'appel illustre comment vous pouvez appeler une méthode non définie. Lorsque vous appelez une méthode non définie, le nom de la méthode et les paramètres reçus par la méthode seront transmis à la méthode appelée, et PHP renverra la valeur de l'appel à la méthode non définie.

<?php 
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()<br>\n"); 
//print("Arguments: "); 
//print_r($args); 
if($method == &#39;display&#39;) 
{ 
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 ("你传入的是个对象，内容如下:<br>"); 
print_r($p); 
echo "<hr>"; 
} 
public function displayArray($p) 
{ 
echo ("你传入的是个数组，内容如下:<br>"); 
print_r($p); 
echo "<hr>"; 
} 
public function displayScalar($p) 
{ 
echo ("你传入的是个单独变量，内容如下:<br>" . $p); 
echo "<hr>"; 
} 
} 
$o = new Overloader(); 
//调用 set() 给一个不存在的属性变量赋值 
$o->dynaProp = "Dynamic Content"; 
//调用 get() 
print($o->dynaProp . "<br>\n"); 
//调用 call() 
//$o->dynaMethod("Leon", "Zeev"); 
$o->display(array(1,2,3)); 
$o->display(&#39;Cat&#39;); 
?>

Dans le code ci-dessus, la méthode display() est appelée et le segment de code correspondant dans la classe peut être appelé en fonction du type et du nombre de paramètres , réalisant ainsi la surcharge de la méthode objet.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!