Comment PHP comprend la surcharge de méthodes et la couverture des méthodes polymorphes

Qu'est-ce que le polymorphisme ?

Polymorphisme signifie littéralement « états multiples ». Dans les langages orientés objet, plusieurs implémentations différentes d'interfaces sont appelées polymorphisme. Citant la description du polymorphisme par Charlie Calverts - Le polymorphisme est une technique qui vous permet de définir un objet parent pour qu'il soit égal à un ou plusieurs de ses objets enfants. Après affectation, l'objet parent peut être attribué à ses objets enfants en fonction de la valeur actuelle. Les fonctionnalités . fonctionnent de différentes manières (à partir de « Insider Delphi 4 Programming Technology »). Pour faire simple, il s'agit d'une phrase : Il est permis d'attribuer un pointeur d'un type de sous-classe à un pointeur d'un type de classe parent (oui, ce passage vient de l'Encyclopédie Baidu). Alors, quel est le rôle du polymorphisme et quelle est sa réelle valeur de développement ? Dans le développement d'applications réelles, l'objectif principal de l'utilisation du polymorphisme orienté objet est que différents objets de sous-classe peuvent être traités comme une seule classe parent, que les différences entre les différents objets de sous-classe peuvent être masquées et que des objets universels peuvent être écrits en code, ce qui permet une programmation générale. s'adapter à l'évolution des besoins.

Voici deux implémentations du polymorphisme en PHP

Surcharge de méthode( surcharge)

la surcharge est une implémentation du polymorphisme de la 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. Autrement dit, lorsqu'elles sont appelées, bien que les noms de méthodes soient les mêmes, les fonctions correspondantes peuvent être automatiquement appelées en fonction de différents paramètres.

class A{
  public function test(){
    echo "test1";
  }
  public function test($a){
    echo "test2";
  }
}
$a=new A();
$a->test();
$a->test($a);

Si php prend directement en charge la surcharge de méthodes. Ensuite, une fois l'exemple ci-dessus exécuté, différentes valeurs seront renvoyées si les paramètres sont transmis et si les paramètres ne sont pas transmis. Cependant, PHP ne prend pas directement en charge la surcharge, ce qui signifie que si vous la définissez directement comme ci-dessus, une erreur sera signalée. Quelle erreur sera signalée ? L'erreur suivante sera signalée.

Cela signifie que la fonction A ne peut pas être définie à plusieurs reprises et que le nombre de lignes signalant l'erreur est exactement la ligne suivante.

public function test($a){

Donc, php ne prend pas directement en charge le rechargement. Le co-auteur dit depuis longtemps que PHP ne le prend pas en charge. . Ne vous inquiétez pas, ce que j'ai dit, c'est qu'il n'est pas directement pris en charge, nous pouvons donc laisser PHP le prendre en charge indirectement. A ce moment, une fonction sera utilisée pour prendre en charge la surcharge. C'est call(). La méthode call() doit prendre deux paramètres. Le premier contient le nom de la méthode appelée, tandis que le second paramètre contient le tableau de paramètres transmis à la méthode. Des fonctions similaires à la surcharge de fonctions peuvent être obtenues grâce à cette méthode. Regardez le code ci-dessous.

public function call($method,$p)
{
  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]);
    }
  }
}
//下面是对上面定义的调用
$ov=new overload;
$ov->display(array(1,2,3));
$ov->display('cat');

Lors de la définition d'une méthode, vous pouvez voir qu'il y a trois branches. Si un objet est passé à la méthode display(), la méthode displayObject() est appelée ; la méthode displayArray() est appelée ); si un autre contenu est transmis, la méthode displayScalar() est appelée. . . Vous pouvez voir que lors de l'appel ci-dessous, la première consiste à transmettre un tableau, puis displayArray() est appelé. Le second transmis n'est ni un objet ni un tableau, il appartient à un autre contenu et la méthode displayScalar() est appelée. Ainsi, la méthode call() est utilisée pour implémenter une surcharge de méthodes similaire à d’autres langages.

Remplacement de méthode (override)

Le soi-disant remplacement est essentiellement une réécriture. Autrement dit, lorsqu'une sous-classe hérite de certaines méthodes de la classe parent et que la sous-classe définit la même méthode en interne, la méthode nouvellement définie remplacera la méthode héritée de la classe parent et la sous-classe ne peut appeler que ses méthodes définies en interne.

a les exigences suivantes :

1 Lorsqu'une classe parent et une sous-classe ont une méthode, les paramètres If. le nom est exactement le même, alors la méthode de la sous-classe remplacera la méthode de la classe parent.

2. Lors de l'implémentation de la couverture de méthode, les modificateurs d'accès peuvent être différents, mais la portée d'accès de la sous-classe doit être supérieure ou égale à la portée d'accès de la classe parent.

3. Les paramètres et les noms doivent être les mêmes. Il n'est pas obligatoire que la sous-classe porte le même nom que la classe parent.

Ce qui suit est une explication de ces points :

Le premier point est que les paramètres doivent être cohérents pour obtenir la couverture de la méthode. Lorsque le nombre de paramètres est incohérent, une erreur sera signalée (cela implique la surcharge des méthodes mentionnées ci-dessus). Lorsque les noms de méthodes sont incohérents, ils ne seront pas écrasés, uniquement les méthodes nouvellement définies de la sous-classe. ;

Le deuxième point est qu'il s'agit de la règle de conception des langages​​comme PHP. Ce que je comprends, c'est qu'il est plus facile d'accéder aux choses à un niveau supérieur. Si vous souhaitez accéder aux choses à un niveau inférieur, vous devez disposer d'autorisations plus élevées.

Regardez le code :

class people{
  protected function sing(){
    echo "人唱歌";
  }
} 
class woman extends people{
  public function sing(){
    echo "女人唱歌";
  }
}
$woman1=new woman();
$woman1->sing();

C'est une sortie normale pour les "femmes qui chantent". Mais lorsque la méthode sing() dans woman est modifiée en proctcted et que l'élément parent est modifié en public(), c'est-à-dire après que l'autorisation d'accès de la classe parent est définie pour être supérieure à celle de la sous-classe, l'erreur suivante sera être signalé.

 

 第三点，是要求参数和名字一样，具体就是要求参数的个数与父类相同，而并不是参数名称一致。即传递的参数名字可以为任意，只要保证传递的个数相同即可。

以上内容简单介绍了PHP语言中多态的两个实现。

PS：重写、覆盖、重载、多态几个概念的区别分析

override->重写(=覆盖)、overload->重载、polymorphism -> 多态

override是重写（覆盖）了一个方法，以实现不同的功能。一般是用于子类在继承父类时，重写（重新实现）父类中的方法。
重写（覆盖）的规则：

   1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.
   2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>default>private）。
   3、重写的方法的返回值必须和被重写的方法的返回一致；
   4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类；
   5、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行重写。
   6、静态方法不能被重写为非静态的方法（会编译出错）。

overload是重载，一般是用于在一个类内实现若干重载的方法，这些方法的名称相同而参数形式不同。

重载的规则：

   1、在使用重载时只能通过相同的方法名、不同的参数形式实现。不同的参数类型可以是不同的参数类型，不同的参数个数，不同的参数顺序（参数类型必须不一样）；
   2、不能通过访问权限、返回类型、抛出的异常进行重载；
   3、方法的异常类型和数目不会对重载造成影响；

多态的概念比较复杂，有多种意义的多态，一个有趣但不严谨的说法是：继承是子类使用父类的方法，而多态则是父类使用子类的方法。

一般，我们使用多态是为了避免在父类里大量重载引起代码臃肿且难于维护。

举个例子：

public class Shape 
{
  public static void main(String[] args){
   Triangle tri = new Triangle();
   System.out.println("Triangle is a type of shape? " + tri.isShape());// 继承
   Shape shape = new Triangle();
   System.out.println("My shape has " + shape.getSides() + " sides."); // 多态
   Rectangle Rec = new Rectangle();
   Shape shape2 = Rec;
   System.out.println("My shape has " + shape2.getSides(Rec) + " sides."); //重载
  }
  public boolean isShape(){
   return true;
  }
  public int getSides(){
   return 0 ;
  }
  public int getSides(Triangle tri){ //重载
   return 3 ;
  }
  public int getSides(Rectangle rec){ //重载
  return 4 ;
  }
}
class Triangle extends Shape 
{
  public int getSides() { //重写,实现多态
   return 3;
  }
}
class Rectangle extends Shape 
{
  public int getSides(int i) { //重载
  return i;
  }
}

注意Triangle类的方法是重写，而Rectangle类的方法是重载。对两者比较，可以发现多态对重载的优点：

如果用重载，则在父类里要对应每一个子类都重载一个取得边数的方法；

如果用多态，则父类只提供取得边数的接口，至于取得哪个形状的边数，怎样取得，在子类里各自实现(重写)。

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!