Qu'est-ce que la surcharge et le dépassement de fonction en php
En PHP, qu'entendez-vous par surcharge de fonctions et neutralisation de fonctions? et quelle est la différence entre les deux? ne pouvait pas comprendre quelle est la différence entre eux.
Overloading définit des fonctions qui ont des signatures similaires mais des paramètres différents. Overriding ne concerne que les classes dérivées, lorsque la classe parent a défini une méthode et que la classe dérivée souhaite override cette méthode.
En PHP, vous ne pouvez surcharger que les méthodes utilisant la méthode magique __call .
Un exemple de overriding:
<?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"
?>
Une surcharge de fonction survient lorsque vous définissez le même nom de fonction deux fois (ou plus) à l'aide d'un jeu 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 compute est surchargée de deux signatures de paramètres différentes. * Ceci n'est pas encore supporté en PHP. Une alternative consiste à utiliser des arguments optionnels:
class Addition {
function compute($first, $second, $third = 0) {
return $first+$second+$third;
}
}
La substitution de fonction survient lorsque vous étendez une classe et réécrivez une fonction qui existait dans la classe parente:
class Substraction extends Addition {
function compute($first, $second, $third = 0) {
return $first-$second-$third;
}
}
Par exemple, compute remplace le comportement défini dans Addition.
Strictement parlant, il n'y a pas de différence, puisque vous ne pouvez pas le faire non plus :)
La substitution de fonction aurait pu être effectuée avec une extension PHP comme APD, mais elle est obsolète et toute dernière version était inutilisable.
La surcharge de fonction dans PHP ne peut pas être effectuée à cause du typage dynamique, c'est-à-dire que dans PHP, vous ne "définissez" pas les variables comme étant d'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 exécution (voir la 4ème) . À titre de comparaison, les autres langages utilisent:
int a=1;
String s="1";
bool a=true;
something a=doSomething();
Dans le dernier exemple, vous devez définir de manière forcée 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 renvoie 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');
Considérant que les deux fonctions acceptent n'importe quelle quantité d'arguments, lequel le compilateur devrait-il choisir?
Enfin, je voudrais indiquer pourquoi les réponses ci-dessus sont partiellement fausses: function overloading/overriding n’est PAS égal à method overloading/overriding.
Lorsqu'une méthode est semblable à une fonction mais spécifique à une classe, dans ce cas, PHP autorise le remplacement dans les classes, mais là encore pas de surcharge, en raison de la sémantique du langage.
Pour conclure, des langages tels que Javascript autorisent le remplacement (mais là encore, 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'
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);
Bien que le paradigme de la surcharge ne soit pas entièrement pris en charge par PHP, le même effet (ou très similaire) peut être obtenu avec un ou plusieurs 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 aurez une fonctionnalité (# 1), mais si vous l'appelez avec un paramètre comme:
f(1);
vous obtiendrez une autre fonctionnalité (n ° 2). C'est l'effet de la surcharge - fonctionnalité différente selon les paramètres d'entrée de la fonction.
Je sais que quelqu'un demandera maintenant quelle fonctionnalité on obtiendra s'il appelle cette fonction f (0).
Je voudrais souligner ici que la surcharge dans PHP a une signification complètement différente de celle des autres langages de programmation. Beaucoup de gens ont dit que la surcharge n'était pas supportée dans PHP et que par la définition conventionnelle de la surcharge, oui, cette fonctionnalité n'est pas explicitement disponible.
Cependant, la définition correcte de la surcharge dans PHP est complètement différente.
Dans 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 non accessibles ou non déclarées.
Voici un lien du manuel PHP: http://www.php.net/manual/fr/language.oop5.overloading.php
La surcharge de méthode se produit lorsque deux méthodes ou plus ont le même nom de méthode, mais un nombre différent de paramètres dans une même classe. PHP ne prend pas en charge la surcharge de méthodes. Le remplacement 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 signifient classe parent et classe enfant.
Surcharge: Dans le monde réel, surcharger signifie attribuer des tâches supplémentaires à quelqu'un. Comme dans le monde réel Surcharger dans PHP signifie appeler des fonctions supplémentaires. Autrement, vous pouvez dire que sa fonction est plus fine avec différents paramètres. Dans 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 remplacement, vous pouvez déclarer de nouveau la méthode de la classe parente dans la classe enfant. Donc, l’objectif de la substitution est de changer le comportement de votre méthode de classe parent.
Exemple de neutralisation:
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
Il existe quelques différences entre la surcharge et le remplacement de fonctions, bien que les deux contiennent le même nom de fonction.En surcharge, les fonctions du même nom contiennent un type d'argument ou de type de retour différent; Tels que: "fonction add (int a, int b)" & "fonction add (float a, float b); Ici, la fonction add () est surchargée . Dans le cas de la substitution, l'argument et le nom de la fonction sont même.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 remplaçant le programmeur suit certaines tactiques pour exécuter la fonction souhaitée où dans la surcharge du programme peut automatiquement identifier la fonction désirée ... Merci!