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 concept de POO en PHP. La surcharge de fonctions ou surcharge de méthodes est une fonctionnalité qui permet de créer plusieurs méthodes portant le même nom, qui diffèrent les unes des autres par le type de paramètres d'entrée. Elle est simplement définie 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. »

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Comment fonctionne la surcharge en PHP ?

Comme nous le savons, la surcharge de méthode est effectuée sur les fonctions. Ainsi, les fonctions peuvent être surchargées avec différentes implémentations basées sur les 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 d'un carré qui est côté * côté, à condition que la longueur d'un côté soit donnée, l'aire d'un triangle est (base *hauteur) / 2 à condition que la longueur de la base et la hauteur soient données et ainsi de suite.

La surcharge du concept nécessite des méthodes magiques.

Les méthodes magiques commencent par __ (double trait de soulignement) et sont appelées 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. Différentes méthodes magiques sont __get(), __set,__construct(), __destruct(), __call(), __callStatic(), __isset(), __unset(),

La surcharge, lorsqu'elle est effectuée, crée dynamiquement des propriétés et des méthodes, qui sont ensemble appelées entités.

Les entités sont également appelées comme

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

Regardons 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 "<pre class="brush:php;toolbar:false">";
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 possède une propriété privée et une méthode __call. Deux arguments sont passés à la méthode __call. Dans la méthode __call, nous avons utilisé l'instruction print(), un var_dump les arguments et une valeur de retour x sont renvoyé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 puisque cette méthode n'existe pas __call() est appelée à 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és
• 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 sont mentionnées les opérations effectuées avec des propriétés surchargées

Propriétés Setter et Getter surchargées (en utilisant __set() et __get())

Évaluation des paramètres de propriétés surchargées (à l'aide de __isset())

Annuler ces paramètres de propriétés (en utilisant __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 désactiver la propriété.

__call() => est utilisé pour initialiser des 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 "<br />". " In the Setting operation. Set '$name = $value'";
$this->details[$name] = $value;
}
// getter operation
public function __get($name) {
echo "<br />". " In the Getting Operation. Get '$name  = '";
return $this->details[$name] . ' <br /> ';
}
// isset operation
public function __isset($name) {
echo "<br />". " In the isset Operation. isset '$name' ?";
return isset($this->details[$name]);
}
// unset operation
public function __unset($name) {
echo "<br />". " In the unset Operation. unset '$name' ";
unset($this->details[$name]);
}
// returning private property value
public function getPrivateProperty() {
return "<br />". " 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 "<br />". $obj-> getPrivateProperty();
//calling directly the private property
// throws error
echo "<br />accessing the private property, throws error";
echo "<br />".$obj->j;

Code :

Sortie

2) Surcharge de méthode

Comme la surcharge de propriétés, la surcharge de méthodes 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(). Celles-ci sont utilisées respectivement en fonction de la référence d'objet et de la référence statique.

__call() -> est utilisé pour appeler des méthodes surchargées dans la référence de l'objet

__callStatic() -> est utilisé pour appeler des méthodes surchargées dans une référence statique

L'exemple suivant vous aidera à en savoir plus.

<?php
class MethodOverloading
{
public function __call($name,$param){
echo "--With object reference <br/>";
}
public static function __callStatic($name,$param){
echo "-----With static reference <br/>";
}
}
// creating object of class MethodOverloading
$obj = new MethodOverloading;
echo "Method Overloading <br/>";
// using the object reference
$obj->DemoTest();
// using the static reference
MethodOverloading::DemoTest();
?>

Code :

Sortie :

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 des propriétés ou des méthodes. Parmi 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 objet, et la moins utilisée est la méthode __callStatic(), qui est utilisée dans le contexte statique.

Article recommandé

Ceci est un guide sur la surcharge en PHP. Nous discutons ici des types et du concept de surcharge en PHP avec des exemples. Vous pouvez également consulter l’article suivant pour en savoir plus –

1. Qu'est-ce que PHP Array ?
2. Surcharge en C#
3. Surcharge en C++
4. Surcharge et remplacement en C#

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!