Que sont la couverture de fonctions et la surcharge de fonctions en PHP

La surcharge et le remplacement de fonctions (également appelés réécriture) sont des fonctionnalités POO (orientées objet) en PHP. En cas de surcharge de fonctions, plusieurs fonctions peuvent avoir le même nom de méthode mais un nombre ou des types de paramètres différents. Mais en cas de remplacement de fonction, plusieurs fonctions auront le même nom de méthode et le même nombre de paramètres.

Surcharge de fonctions : La surcharge de fonctions contient le même nom de fonction qui effectue des tâches différentes en fonction du nombre et du type d'arguments.

Par exemple, pour trouver l'aire d'une certaine forme étant donné le rayon, si la hauteur et la largeur sont données, l'aire du cercle doit être renvoyée, puis l'aire rectangulaire et les autres aires doivent être renvoyées donné. Comme les autres langages POO, la surcharge de fonctions ne peut pas être effectuée via des méthodes natives.

En PHP, la surcharge de fonctions se fait à l'aide de la méthode magique __call(). Cette fonction prend un nom de fonction et des paramètres.

Exemple de surcharge de fonction :

<?php 
// 说明:PHP程序说明函数。
// PHP中的重载
//创建一个类型为shape的类
class shape { 
      
   // __call() 是一个魔术方法
   //函数名和参数
    function __call($name_of_function, $arguments) { 
              
        // 它将匹配函数名
        if($name_of_function == &#39;area&#39;) { 
              
            switch (count($arguments)) { 
                      
                // 如果只有一个参数
                //圆的面积
                case 1: 
                    return 3.14 * $arguments[0]; 
                          
                // 如果有两个参数，则面积为矩形;
                case 2: 
                    return $arguments[0]*$arguments[1]; 
            } 
        } 
    } 
} 
      
//声明Shape类型对象
$s = new Shape; 
      
echo($s->area(2)); 
echo "<br>"; 
      
// 调用矩形的area方法
echo ($s->area(4, 2)); 
?>

Sortie :

6.28
8

Réécriture de fonction : Réécriture de fonction Écrit le comme les autres langages de programmation POO. Lors du remplacement de fonction, la classe parent et la classe enfant doivent avoir le même nom de fonction et le même nombre de paramètres. Il est utilisé pour remplacer la méthode parent dans la classe enfant. Le but de la substitution est de modifier le comportement de la méthode de la classe parent. Deux méthodes portant le même nom et les mêmes paramètres sont appelées remplacements.

Exemple de couverture de fonctions (réécriture) :

<?php
//PHP程序实现
//函数覆盖
//这是父类
class P {

    // 父类函数demo
    function demo() {
        echo "Parent";
    }
}

// 这是子类
class C extends P {

    // 覆盖demo方法
    function demo() {
        echo "<br>Child";
    }
}


$p = new P;

$c= new C;

// 打印parent
$p->demo();

// 打印child
$c->demo();
?>

Sortie :

Parent
Child

Cet article concerne la couverture de fonctions en PHP et le introduction de la surcharge de fonctions, j'espère que cela sera utile aux amis dans le besoin !

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!