Exemple comparant deux façons de surcharger les méthodes 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 paramètre numéro ou type de paramètre de la fonction, afin qu'il n'y ait pas de confusion dans 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 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, utiliser la surcharge en PHP5

Regardez d'abord l'exemple suivant :

Le code est le suivant :

<?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 中是不正确的！ 
?>

Les personnes qui ont utilisé la surcharge en C++, Java et C# sont habituées à écrire le code PHP pour l'implémentation de 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.

Le code est le suivant :

<?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 code correspondant dans la classe peut être appelé selon le type et le nombre de paramètres de la section, réalisant ainsi la surcharge des méthodes 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!