Surcharge en PHP - Types et concept de surcharge en PHP

Qu'est-ce que la surcharge en PHP?

Nous avons différents concepts de programmation orientée objet comme la classe, l'objet, l'encapsulation, le polymorphisme, etc. en PHP. La surcharge est également un tel concept de POO en PHP.

La surcharge de fonctions ou la surcharge de méthodes est une fonctionnalité qui permet de créer plusieurs méthodes avec le même nom qui diffèrent les unes des autres par le type de paramètres d'entrée. Il est simplement défini comme la capacité d'une fonction à effectuer différentes tâches.

Définition de la surcharge sur une seule ligne: «même nom mais implémentations différentes»

Comment fonctionne la surcharge en PHP?

Comme nous le savons, une surcharge de méthode est effectuée sur les fonctions. Ainsi, les fonctions peuvent être surchargées avec différentes implémentations en fonction des arguments passés à chaque fonction. Par exemple, pour trouver l'aire d'un cercle qui est pi * r * r à condition que le rayon soit donné, pour trouver l'aire du carré qui est côté * côté, à condition que la longueur du côté soit donnée, l'aire d'un triangle est (base * hauteur) / 2 à condition que la longueur de base et la hauteur soient données et ainsi de suite.

Le concept de surcharge nécessite des méthodes Magic.

Magic Methods commence par __ (double soulignement) et est appelé automatiquement par PHP. De plus, ceux-ci sont toujours définis à l'intérieur de la classe et non à l'extérieur de la classe. Les différentes méthodes magiques sont __get (), __set, __ construct (), __destruct (), __call (), __callStatic (), __isset (), __unset (),

La surcharge, une fois effectuée, crée dynamiquement des propriétés et des méthodes qui sont ensemble appelées les entités.

Les entités sont également appelées

• propriétés: membres de données
• méthodes: fonctions de données

Voyons comment fonctionne la méthode magique en utilisant la méthode __call ()

<_?php
class Test(
private $a = array('one', 'two', 'three');
public function__call($method, $args) (
print "Method $method called:\n";
echo " ";
print_r($args);
return $this->a;
)
)
$obj = new Test();
$a = obj->anyMethod(1, 2, 3);
var_dump($a);
?>

 class Test(
private $a = array('one', 'two', 'three');
public function__call($method, $args) (
print "Method $method called:\n";
echo " ";
print_r($args);
return $this->a;
)
)
$obj = new Test();
$a = obj->anyMethod(1, 2, 3);
var_dump($a);
?>


Dans l'exemple ci-dessus, nous avons déclaré une classe appelée Test qui a une propriété privée et une méthode __call. Deux arguments sont passés à la méthode __call. A l'intérieur de la méthode __call, nous avons utilisé l'instruction print (), un var_dump les arguments et une valeur x sont retournés.


Ensuite, l'objet de la classe portant le nom obj est créé et en utilisant cet objet, une méthode non définie est appelée car cette méthode n'existe pas. __Call () est appelé à la place.
Types de surcharge en PHP
Il existe deux types de surcharge en PHP et apprenons chaque type en détail.

Surcharge de propriété
Surcharge de méthode

1) Surcharge de propriété
La surcharge de propriétés crée des propriétés dynamiques lorsque l'objet est défini. Cette propriété est associée à l'instance de classe et si cette propriété n'est pas déclarée dans l'étendue de la classe, elle est considérée comme une propriété surchargée. Pour cela, vous n'avez pas besoin d'écrire de code supplémentaire. Les méthodes magiques suivantes nous en disent plus sur la même chose.

Ci-dessous, les opérations effectuées avec des propriétés surchargées
Propriétés surchargées Setter et Getter (en utilisant __set () et __get ())
Évaluation du paramètre de propriétés surchargées (à l'aide de __isset ())
Annuler ce paramètre de propriétés (à l'aide de __unset ())
Comprenons l'utilisation de chacune de ces méthodes
__set () => est utilisé pour initialiser les propriétés surchargées.
__get () => est utilisé pour récupérer les propriétés déjà initialisées


__isset () => est utilisé pour vérifier si la propriété est définie ou non
__unset () => est utilisé pour annuler la propriété.
__call () => est utilisé pour initialiser les méthodes surchargées
__callStatic () => est utilisé pour initialiser les méthodes statiques
Toutes les méthodes ci-dessus sont utilisées ensemble dans l'exemple suivant.
Code:
class PropertyOverloading (
public $details = array();
//declaring private property
private $j=20;
// setter operation
public function __set($name, $value) (
echo "
". " In the Setting operation. Set '$name = $value'";
$this->details($name) = $value;
)
// getter operation
public function __get($name) (
echo "
". " In the Getting Operation. Get '$name = '";
return $this->details($name) . '
';
)
// isset operation
public function __isset($name) (
echo "
". " In the isset Operation. isset '$name' ?";
return isset($this->details($name));
)
// unset operation
public function __unset($name) (
echo "
". " In the unset Operation. unset '$name' ";
unset($this->details($name));
)
// returning private property value
public function getPrivateProperty() (
return "
". " j = ".$this->j;
)
)
// creating object of class PropertyOverloading
// setter and getter methods are called
$obj = new PropertyOverloading();
$obj->x = 10;
echo $obj->x;
//call isset method
var_dump(isset($obj->x));
//call unset method
unset($obj->x);
//check whether object x is unset or not
var_dump(isset($obj->x));
//getting method to access the private property
echo "
". $obj-> getPrivateProperty();
//calling directly the private property
// throws error
echo "
accessing the private property, throws error";
echo "
".$obj->j;



Code:

Production

2) Surcharge de méthode
Comme la surcharge de propriété, la surcharge de méthode crée une méthode dynamique qui est déclarée en dehors de l'étendue de la classe. Et cela est possible avec les méthodes magiques __call () et __callStatic (). Ils sont utilisés en fonction de la référence d'objet et de la référence statique respectivement.
__call () -> est utilisé pour appeler des méthodes surchargées dans la référence d'objet
__callStatic () -> est utilisé pour appeler des méthodes surchargées en référence statique
L'exemple suivant vous aidera à en savoir plus.
<_?php
class MethodOverloading
(
public function __call($name, $param)(
echo "--With object reference
";
)
public static function __callStatic($name, $param)(
echo "-----With static reference
";
)
)
// creating object of class MethodOverloading
$obj = new MethodOverloading;
echo "Method Overloading
";
// using the object reference
$obj->DemoTest();
// using the static reference
MethodOverloading::DemoTest();
?>
Code:

Production:

Règles
1) Le spécificateur d'accès public est utilisé pour les méthodes de surcharge.
2) Le processus de surcharge est utilisé dans lequel les propriétés ou méthodes non définies dans l'étendue de la classe sont accessibles, lors de la création de l'objet de la classe.
3) Les méthodes magiques sont utilisées pour surcharger les propriétés ou méthodes. Sur les deux méthodes magiques utilisées pour surcharger les méthodes, la méthode la plus utilisée est la méthode __call () dans le contexte de l'objet et la méthode __callStatic () qui est utilisée dans le contexte statique est moins utilisée.

Article recommandé
Ceci est un guide de surcharge en PHP. Nous discutons ici des types et du concept de surcharge en PHP avec les exemples. Vous pouvez également consulter l'article suivant pour en savoir plus -

Qu'est-ce que PHP?
Qu'est-ce que PHP Array?
Questions d'entretiens chez Core PHP
Fonctions de chaîne PHP
Surcharge en C # | Comment ça fonctionne?
Introduction à la surcharge en C ++
Méthode statique en PHP
Surcharge et remplacement en C #
Méthode magique Python | Méthodes, composants (exemples)