Surcharge de méthode en PHP

La surcharge de méthode est un type de surcharge autre que la surcharge de propriété. Il s'agit de créer une/plusieurs méthodes dynamiques non créées dans cette portée/portée de classe. Le concept de surcharge de méthodes PHP permet également de déclencher les méthodes magiques dictées dans le but approprié. Outre le concept de surcharge de propriétés, le concept de surcharge de la méthode PHP permet des appels de fonction à la fois sur l'objet et sur le contexte statique. C'est essentiellement l'une des méthodes de POO.

PUBLICITÉ Cours populaire dans cette catégorie DEVELOPPEUR PHP - Spécialisation | Série de 8 cours | 3 tests simulés

Commencez votre cours de développement de logiciels libres

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

Syntaxe :

Public _call (string $name1 , array $arguments1 ) : mixed
Public static _callStatic (string $name1 , array $arguments1 ) : mixed

Comment fonctionne la surcharge de méthodes en PHP ?

Method Overloading fonctionne avec la déclaration à l'intérieur de la classe en créant des méthodes dynamiques. Il fonctionne également en déclenchant certaines méthodes magiques dans un but approprié et appelle des appels de fonction/fonction à la fois sur le contexte statique et sur l'objet. Le concept de surcharge de méthode convient également à la plupart des autres langages de programmation comme C, Java, etc. Nous appelons la surcharge de méthode un polymorphisme statique.

Il existe certaines des fonctions magiques, ce sont :

• _call() : Le contexte d'un objet peut déclencher l'exécution de méthodes surchargées à l'aide de la fonction call().
• _callStatic() : La fonction magique callstatic() active les concepts/méthodes surchargés dans le contexte statique.

Exemples de surcharge de méthodes en PHP

Voici les exemples de surcharge de méthode en PHP mentionnés ci-dessous

Exemple n°1

L'argument $name1, dans le langage de programmation PHP ci-dessous, est le nom de la méthode à appeler, tandis que $arguments est l'un des tableaux énumérés contenant les paramètres/arguments utilisés pour passer à la méthode $name' ed.

Fonction _call() utilisée en utilisant 2 paramètres $name1 et $arguments1. La fonction Implode() renvoie une chaîne à partir des éléments du tableau, c'est-à-dire à partir de la chaîne/phrase. Dans Implode(separator, array), le séparateur est le paramètre facultatif, mais il s'agit simplement d'une recommandation d'utiliser les deux paramètres pour des raisons de compatibilité ascendante. Le type spécifique de séparateur dans le paramètre separator insérera un séparateur dans les mots/chaînes présents dans le paramètre array.

La variable Obj créera un nouvel objet appelé SPK. Objet-> aidera à accéder aux méthodes et propriétés de l’objet. Spk s'exécutera à partir du contexte statique, tandis que l'obj s'exécutera à partir du contexte objet.

Code :

<?php
class SPK {
public function __call($name1, $arguments1) {
echo "object method calling '$name1' "
. implode(', ', $arguments1). "\n";
}
public static function __callStatic($name1, $arguments1) {
echo "static method Calling '$name1' "
. implode(', ', $arguments1). "\n";
}
}
// Create new object
$obj = new SPK;
$obj->runTest('in one of the object context');
SPK::runTest('in one of the static context');
?>

Sortie :

Exemple n°2

L'exemple de code définit la classe foo1 avec une seule fonction _call() qui exécute la fonction die() pour afficher un message et terminer le script PHP en cours. Die() est identique à la fonction exit(), qui n'accepte qu'un seul paramètre entre parenthèses.

Foo1-> aidera à accéder aux méthodes et propriétés de l'objet à partir de la variable $foo1.

Code :

<?php
class Foo1 {
function __call($m1, $a1) {
die($m1);
}
}
$foo1 = new Foo1;
print $foo1->{' wow !'}();
// outputs ' wow !'
?>

Sortie :

Exemple #3

Ceci est un exemple de surcharge de méthodes dans le langage de programmation PHP utilisant la fonction call() et les méthodes privées/protégées.

Ici, l'appel des méthodes privées/protégées se fait en accédant par une faute de frappe ou quelque chose du genre, etc.

Echo _METHOD_PHP_EOL renverra le type de méthode utilisé. Il utilise uniquement la fonction _call(), qui s'exécute à partir du contexte de l'objet.

Code :

<?php
class TestMagicCallMethod1 {
public function foo1()
{
echo __METHOD__.PHP_EOL;
}
public function __call($method1, $args1)
{
echo __METHOD__.PHP_EOL;
if(method_exists($this, $method1))
{
$this->$method1();
}
}
protected function bar1()
{
echo __METHOD__.PHP_EOL;
}
private function baz1()
{
echo __METHOD__.PHP_EOL;
}
}
$test    =    new TestMagicCallMethod1();
$test->foo1();
$test->bar1();
$test->baz1();
?>

Sortie :

Exemple n°4

Il s'agit du programme du concept de fonctions call() et call static(), qui est utilisé pour le concept de surcharge de méthode. Ce programme PHP ci-dessous appellera d'abord la fonction _call() avant la fonction _callstatic() dans l'instance.

Var dump() fournira des informations sur la variable entre parenthèses en PHP et dans certains autres langages de programmation orientés objet. A part ça, tout est pareil, tout comme les exemples ci-dessus.

Code :

<?php
class A1 {
public function test1 () {
static::who();
A1::who();
self::who();
$this->who();
}
public static function __callStatic($a1, $b1) {
var_dump('A1 static');
}
public function __call($a1, $b1) {
var_dump('A1 call');
}
}
$a1 = new A1;
$a1->test1();
?>

Sortie :

Exemple #5

Voici l'exemple de la fonction _call() ; si la classe de l'objet est appelée avec la méthode, qui n'existe même pas, alors le concept de la fonction _call() est appelé à la place de la méthode.

Execute the _call() function to support the concept of method overloading through the dynamic area() method included in the PHP program below. The object’s behavior will vary depending on the parameters that pass to it.

Code:

<?php
class Shape1 {
const PI1 = 3.142 ;
function __call($name1,$arg1){
if($name1 == 'area1')
switch(count($arg1)){
case 0 : return 0 ;
case 1 : return self::PI1 * $arg1[0] ;
case 2 : return $arg1[0] * $arg1[1];
}
}
}
$circle1 = new Shape1();
echo $circle1->area1(3);
$rect1 = new Shape1();
echo $rect1->area1(8,6);
?>

Output:

Example #6

Here, the _call() and _callstatic() functions are used like in the 1^st example.

Code:

<?php
class Toys1
{
public function __call($name1,$pavan1){
echo "Magic method invoked while method overloading with object reference";
}
public static function __callStatic($name1,$pavan1){
echo "Magic method invoked while method overloading with static access";
}
}
$objToys1 = new Toys1;
$objToys1->overloaded_method();
Toys1::overloaded_property();
?>

Output:

Example #7

The call () function of method Overloading triggered and invoked the inaccessible methods in the object context. Call() is mixed with the syntax _call(string $name1 , array $arguments1).

Then $name1 parameter is for the name of the method which is to be called, whereas the array $arguments1 is the parameter that is an enumerated array that contains/has the parameters which are to be passed to the $name variables method.

Code:

<?php
class ABC1 {
public function __call($method_name1, $arguments1) {
$methodArray1 = array('displayMessage11','displayMessage12');
if (in_array($method_name1,$methodArray1) === false) {
die("\n Method does not exist");
}
if (count($arguments1) === 2) {
$this->displayMessage12($arguments1[0],$arguments1[1]);
}
elseif (count($arguments1) === 1) {
$this->displayMessage11($arguments1[0]);
} else {
echo "\n unknown method";
return false;
}
}
function displayMessage11($var11) {
echo "\n from func1($var11)";
}
function displayMessage12($var11,$var12) {
echo "\n from func2($var11,$var12)";
}
}
$obj1 = new ABC1;
$obj1->displayMessage11('hello');
$obj1->displayMessage12('hello','hello2');
$obj1->displayMessage13('Hello');
?>

Output:

Example #8

It is also just like the first example program. Check it once.

Code:

<?php
class MethodOverloading1
{
public function __call($name1,$pavan1){
echo "\n--It is now With the object reference ";
}
public static function __callStatic($name1,$pavan1){
echo "\n-----It is now With the static reference \n";
}
}
// Here now creating the object of the class " MethodOverloading "
$obj1 = new MethodOverloading1;
echo "Method Overloading1 Now in Command ";
// Now using the object's reference
$obj1->DemoTest1();
// Now using the static's reference
MethodOverloading1::DemoTest1();
?>

Output:

Example #9

This program shows the area of the circle and rectangle using some parameters and the call() function of the method overloading concept. The program will only run with the object context due to the object assigning an object variable to the class, etc.

Code:

<?php
class TDshape1 {
const Pi1 = 3.142 ;  // constant value
function __call($fname1, $argument1){
if($fname1 == 'area1')
switch(count($argument1)){
case 0 : return 0 ;
case 1 : return self::Pi1 * $argument1[0] ; // 3.14 * 15
case 2 : return $argument1[0] * $argument1[1];  // 5 * 11
}
}
}
$circle1 = new TDshape1();
echo "Area of the circle:".$circle1->area1(15); // display output of the area of circle
$rect1 = new TDshape1();
echo "\n Area of the rectangle:".$rect1->area1(5,11); // display output of the area of rectangle
?>

Output:

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!