Qu'est-ce que la surcharge et la surcharge de fonctions en PHP?

Réponses:

192

La surcharge définit des fonctions qui ont des signatures similaires, mais qui ont des paramètres différents. Le remplacement n'est pertinent que pour les classes dérivées, où la classe parente a défini une méthode et la classe dérivée souhaite remplacer cette méthode.

En PHP, vous ne pouvez surcharger que les méthodes utilisant la méthode magique __call.

Un exemple de remplacement :

<?php

class Foo {
   function myFoo() {
      return "Foo";
   }
}

class Bar extends Foo {
   function myFoo() {
      return "Bar";
   }
}

$foo = new Foo;
$bar = new Bar;
echo($foo->myFoo()); //"Foo"
echo($bar->myFoo()); //"Bar"
?>
Jacob Relkin
la source
31
Cependant, PHP ne prend pas en charge la surcharge.
Sasha Chedygov
18
Oui, c'est le cas, en utilisant __call.
Jacob Relkin
50
PHP remplace la surcharge via des paramètres optionnels.
b01
3
Merci pour l'idée de paramètres facultatifs, c'est un indice vraiment utile
Fabricio PH
2
__call () est déclenché lorsque des méthodes inaccessibles sont appelées dans le contexte des objets La méthode mégique __callStatic () est déclenchée lorsque des méthodes inaccessibles sont appelées dans un contexte statique. Suivez ceci pour obtenir un exemple et une explication plus détaillés de la surcharge en contexte PHP
Code Buster
107

La surcharge de fonction se produit lorsque vous définissez le même nom de fonction deux fois (ou plus) en utilisant un ensemble de paramètres différent. Par exemple:

class Addition {
  function compute($first, $second) {
    return $first+$second;
  }

  function compute($first, $second, $third) {
    return $first+$second+$third;
  }
}

Dans l'exemple ci-dessus, la fonction computeest surchargée avec deux signatures de paramètres différentes. * Ceci n'est pas encore pris en charge en PHP. Une alternative consiste à utiliser des arguments optionnels:

class Addition {
  function compute($first, $second, $third = 0) {
    return $first+$second+$third;
  }
}

Le remplacement de fonction se produit lorsque vous étendez une classe et réécrivez une fonction qui existait dans la classe parent:

class Substraction extends Addition {
  function compute($first, $second, $third = 0) {
    return $first-$second-$third;
  }
}

Par exemple, computeremplace le comportement défini dans Addition.

Andrew Moore
la source
9
Sauf que la surcharge de fonctions n'est pas prise en charge en PHP, AFAIK. De plus, en guise de note secondaire, je ne sais pas pourquoi vous voudriez qu'une Subtractionclasse étende la Additionclasse. :)
Sasha Chedygov
6
@musicfreak: 00h40 heure locale ... Je ne pouvais pas penser à un meilleur exemple.
Andrew Moore
5
Ceci n'est pas encore pris en charge en PHP et ne le sera probablement jamais, car PHP est un langage faiblement typé et rien ne changera dans ce cas.
Crozin
2
La surcharge ne se produit pas uniquement lorsque vous définissez le même nom de fonction deux fois (ou plusieurs fois) à l'aide d'un ensemble de paramètres différent. Généralement, la surcharge se produit également lorsque vous définissez le même nom de fonction deux fois (ou plus) en utilisant le même nombre de paramètres mais de types différents. Comme en PHP il n'y a pas de déclaration de type de variable (comme en Java), cette généralisation n'a pas d'importance. Je mentionne simplement cela par souci de précision ce qu'est la surcharge.
sbrbot
2
@sbrbot: Set implique à la fois un nombre et des types.
Andrew Moore
22

À proprement parler, il n'y a pas de différence, puisque vous ne pouvez pas faire non plus :)

Le remplacement de fonction aurait pu être fait avec une extension PHP comme APD, mais il est obsolète et la dernière version afaik était inutilisable.

La surcharge de fonctions en PHP ne peut pas être effectuée à cause du typage dynamique, c'est-à-dire qu'en PHP vous ne "définissez" pas les variables comme étant un type particulier. Exemple:

$a=1;
$a='1';
$a=true;
$a=doSomething();

Chaque variable est d'un type différent, mais vous pouvez connaître le type avant l'exécution (voir la 4e). A titre de comparaison, d'autres langues utilisent:

int a=1;
String s="1";
bool a=true;
something a=doSomething();

Dans le dernier exemple, vous devez forcer le type de la variable (par exemple, j'ai utilisé le type de données "quelque chose").


Un autre "problème" pour lequel la surcharge de fonction n'est pas possible en PHP: PHP a une fonction appelée func_get_args (), qui retourne un tableau d'arguments courants, considérons maintenant le code suivant:

function hello($a){
  print_r(func_get_args());
}

function hello($a,$a){
  print_r(func_get_args());
}

hello('a');
hello('a','b');

Étant donné que les deux fonctions acceptent n'importe quelle quantité d'arguments, lequel doit choisir le compilateur?


Enfin, je voudrais souligner pourquoi les réponses ci-dessus sont partiellement fausses; la surcharge / substitution de fonction n'est PAS égale à la surcharge / substitution de méthode .

Lorsqu'une méthode est comme une fonction mais spécifique à une classe, auquel cas, PHP permet de surcharger dans les classes, mais encore une fois pas de surcharge, en raison de la sémantique du langage.

Pour conclure, des langages comme Javascript autorisent le remplacement (mais encore une fois, pas de surcharge), mais ils peuvent également montrer la différence entre le remplacement d'une fonction utilisateur et une méthode:

/// Function Overriding ///

function a(){
   alert('a');
}
a=function(){
   alert('b');
}

a(); // shows popup with 'b'


/// Method Overriding ///

var a={
  "a":function(){
    alert('a');
  }
}
a.a=function(){
   alert('b');
}

a.a(); // shows popup with 'b'
Christian
la source
2
PHP 5.xx ne prend pas en charge la surcharge, c'est pourquoi PHP n'est pas entièrement en POO.
PHP Ferrari
30
Ce n'est pas que PHP ne supporte pas la surcharge, c'est que cela n'a pas de sens. Le problème est dû au fait que PHP utilise des types dynamiques. En fait, Javascript ne supporte pas non plus la surcharge, et c'est toujours la POO. Le fud «PHP n'est pas entièrement POO» n'existe que parce que certaines personnes ont décidé d'utiliser une check-list pour juger de ce qui est OOP ou non.
Christian
@ ringø Non, les fonctions nommées en PHP sont immuables. Une fois que vous avez créé une fonction nommée en PHP, il n'y a aucun moyen de modifier son comportement interne (remplacement). À moins que vous ne parliez de remplacement de méthode, ce qui est autre chose. Vous devriez probablement lire toute la réponse avant de commenter la première ligne. :)
Christian
@Christian Eh bien, bien sûr, en PHP (et dans de nombreux autres langages), le remplacement se produit dans une classe . Donc, oui, nous parlons de méthodes - même si chacune d'elles est précédée de la fonction mot-clé . Mais en effet, j'aurais dû lire toute la réponse en premier ...
e2-e4
9

Exemple de surcharge

class overload {
    public $name;
    public function __construct($agr) {
        $this->name = $agr;
    }
    public function __call($methodname, $agrument) {
         if($methodname == 'sum2') {

          if(count($agrument) == 2) {
              $this->sum($agrument[0], $agrument[1]);
          }
          if(count($agrument) == 3) {

              echo $this->sum1($agrument[0], $agrument[1], $agrument[2]);
          }
        }
    }
    public function sum($a, $b) {
        return $a + $b;
    }
    public function sum1($a,$b,$c) {

        return $a + $b + $c;
    }
}
$object = new overload('Sum');
echo $object->sum2(1,2,3);
Marche
la source
Belle implémentation personnalisée, mais elle devrait être donnée par la langue.
4EACH
Ce n'est pas une méthode, une surcharge de fonction, alors que vous utilisez un nom de méthode différent pour chaque puporse
TomSawyer
5

Bien que le paradigme de surcharge ne soit pas entièrement pris en charge par PHP, le même effet (ou très similaire) peut être obtenu avec le ou les paramètres par défaut (comme quelqu'un l'a mentionné précédemment).

Si vous définissez votre fonction comme ceci:

function f($p=0)
{
  if($p)
  {
    //implement functionality #1 here
  }
  else
  {
    //implement functionality #2 here
  }
}

Lorsque vous appelez cette fonction comme:

f();

vous obtiendrez une fonctionnalité (# 1), mais si vous l'appelez avec un paramètre comme:

f(1);

vous obtiendrez une autre fonctionnalité (# 2). C'est l'effet de la surcharge - des fonctionnalités différentes selon les paramètres d'entrée de la fonction.

Je sais, quelqu'un va demander maintenant quelle fonctionnalité on obtiendra s'il appelle cette fonction comme f (0).

sbrbot
la source
1

Je tiens à souligner ici que la surcharge en PHP a une signification complètement différente par rapport aux autres langages de programmation. Beaucoup de gens ont dit que la surcharge n'est pas prise en charge en PHP et par la définition conventionnelle de la surcharge, oui, cette fonctionnalité n'est pas explicitement disponible.

Cependant, la définition correcte de la surcharge en PHP est complètement différente.

En PHP, la surcharge fait référence à la création dynamique de propriétés et de méthodes à l'aide de méthodes magiques telles que __set () et __get (). Ces méthodes de surcharge sont appelées lors de l'interaction avec des méthodes ou des propriétés qui ne sont pas accessibles ou non déclarées.

Voici un lien du manuel PHP: http://www.php.net/manual/en/language.oop5.overloading.php

Ram Iyer
la source
1

La surcharge de méthode se produit lorsque deux méthodes ou plus avec le même nom de méthode mais un nombre différent de paramètres dans une seule classe. PHP ne prend pas en charge la surcharge de méthode. La substitution de méthode signifie que deux méthodes avec le même nom de méthode et le même nombre de paramètres dans deux classes différentes signifie la classe parent et la classe enfant.

Shriyash Deshmukh
la source
0

Il y a quelques différences entre la surcharge de fonction et le remplacement, bien que les deux contiennent le même nom de fonction. En surcharge, les fonctions de même nom contiennent un type d'argument ou un type de retour différent; comme: "function add (int a, int b)" & " function add (float a, float b); Ici, la fonction add () est surchargée. En cas de substitution, l'argument et le nom de la fonction sont identiques.Il se trouve généralement dans l'héritage ou dans les traits.Nous devons suivre certaines tactiques pour introduire , quelle fonction sera exécutée maintenant. Donc, en écrasant le programmeur suit quelques tactiques pour exécuter la fonction désirée où dans la surcharge le programme peut identifier automatiquement la fonction désirée ... Merci!

Mashuq Tanmoy
la source
0

Surcharge: Dans le monde réel, la surcharge signifie attribuer des choses supplémentaires à quelqu'un. Comme dans le monde réel, la surcharge en PHP signifie appeler des fonctions supplémentaires. D'une autre manière, vous pouvez dire qu'il a une fonction plus mince avec des paramètres différents.En PHP, vous pouvez utiliser la surcharge avec des fonctions magiques, par exemple __get, __set, __call etc.

Exemple de surcharge:

class Shape {
   const Pi = 3.142 ;  // constant value
  function __call($functionname, $argument){
    if($functionname == 'area')
    switch(count($argument)){
        case 0 : return 0 ;
        case 1 : return self::Pi * $argument[0] ; // 3.14 * 5
        case 2 : return $argument[0] * $argument[1];  // 5 * 10
    }

  }

 }
 $circle = new Shape();`enter code here`
 echo "Area of circle:".$circle->area()."</br>"; // display the area of circle Output 0
 echo "Area of circle:".$circle->area(5)."</br>"; // display the area of circle
 $rect = new Shape();
 echo "Area of rectangle:".$rect->area(5,10); // display area of rectangle

Remplacement: dans la programmation orientée objet, le remplacement consiste à remplacer la méthode parente dans la classe enfant.En cas de remplacement, vous pouvez re-déclarer la méthode de la classe parent dans la classe enfant. Donc, fondamentalement, le but de la substitution est de changer le comportement de votre méthode de classe parente.

Exemple de remplacement:

class parent_class
{

  public function text()    //text() is a parent class method
  {
    echo "Hello!! everyone I am parent class text method"."</br>";
  }
  public function test()   
  {
    echo "Hello!! I am second method of parent class"."</br>";
  }

}

class child extends parent_class
{
  public function text()     // Text() parent class method which is override by child 
  class
  {
    echo "Hello!! Everyone i am child class";
  }

 }

 $obj= new parent_class();
 $obj->text();            // display the parent class method echo
 $obj= new parent_class();
 $obj->test();
 $obj= new child();
 $obj->text(); // display the child class method echo
user3040433
la source
-14

PHP 5.xx ne prend pas en charge la surcharge, c'est pourquoi PHP n'est pas entièrement en POO.

PHP Ferrari
la source
18
Je ne sais pas d'où vous est venue l'idée de surcharger une exigence de programmation orientée objet.
match nul le
6
@drewish parce que le polymorphisme paramétrique est l'une des caractéristiques les plus importantes de la POO?
Davor
1
@drewish si vous comptez le polymorphisme comme l'une des principales stagnations de la POO. Ensuite, la surcharge est apparemment disponible pour la compilation. Cependant, la surcharge de méthode est le polymorphisme au moment de la compilation et également connu sous le nom de polymorphisme statique.
Yasir Arefin