Methodenüberladung in PHP

Methodenüberladung ist eine andere Art von Überladung als Eigenschaftsüberladung. Es geht darum, eine oder mehrere dynamische Methoden zu erstellen, die nicht innerhalb dieses Klassenbereichs/Bereichs erstellt wurden. Das PHP-Methodenüberladungskonzept hilft auch dabei, die magischen Methoden auszulösen, die für den entsprechenden Zweck vorgegeben sind. Abgesehen vom Konzept der Eigenschaftsüberladung ermöglicht das Überladungskonzept der PHP-Methode Funktionsaufrufe sowohl für das Objekt als auch für den statischen Kontext. Im Grunde ist es eine der Methoden von OOPs.

WERBUNG Beliebter Kurs in dieser Kategorie PHP-ENTWICKLER - Spezialisierung | 8-Kurs-Reihe | 3 Probetests

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Syntax:

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

Wie funktioniert Methodenüberladung in PHP?

Methodenüberladung funktioniert mit der Deklaration innerhalb der Klasse, indem dynamische Methoden erstellt werden. Es funktioniert auch, indem es einige magische Methoden für einen geeigneten Zweck auslöst und Funktionen/Funktionsaufrufe sowohl für den statischen Kontext als auch für das Objekt aufruft. Das Konzept der Methodenüberladung funktioniert auch gut mit den meisten anderen Programmiersprachen wie C, Java usw. Wir bezeichnen Methodenüberladung als statischen Polymorphismus.

Es gibt einige der magischen Funktionen, sie sind:

• _call(): Der Kontext eines Objekts kann die Ausführung überladener Methoden mithilfe der Funktion call() auslösen.
• _callStatic(): Die magische Funktion callstatic() aktiviert die überladenen Konzepte/Methoden im statischen Kontext.

Beispiele für Methodenüberladung in PHP

Hier sind die unten aufgeführten Beispiele für Methodenüberladung in PHP

Beispiel #1

Das $name1-Argument ist in der folgenden PHP-Programmiersprache der Name der aufzurufenden Methode, während $arguments eines der aufgezählten Arrays ist, das die Parameter/Argumente enthält, die zur Übergabe an die $name'ed-Methode verwendet werden.

_call()-Funktion, die mit 2 Parametern $name1 und $arguments1 verwendet wird. Die Funktion Implode() gibt eine Zeichenfolge aus den Array-Elementen zurück, d. h. aus der Zeichenfolge/dem Satz. In Implode(separator, array) ist das Trennzeichen der optionale Parameter, es handelt sich jedoch lediglich um eine Empfehlung, aus Gründen der Abwärtskompatibilität beide Parameter zu verwenden. Der spezifische Trennzeichentyp im Trennzeichenparameter fügt ein Trennzeichen in die im Array-Parameter vorhandenen Wörter/Zeichenfolgen ein.

Die Obj-Variable erstellt ein neues Objekt namens SPK. Obj-> hilft beim Zugriff auf die Methoden und Eigenschaften des Objekts. Spk wird aus dem statischen Kontext ausgeführt, während obj aus dem Objektkontext ausgeführt wird.

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');
?>

Ausgabe:

Beispiel #2

Das Codebeispiel definiert die Klasse foo1 mit einer einzelnen _call()-Funktion, die die die()-Funktion ausführt, um eine Nachricht anzuzeigen und das aktuelle PHP-Skript zu beenden. Die() ist dasselbe wie die Funktion exit(), die nur einen Parameter in ihrer Klammer akzeptiert.

Foo1-> hilft beim Zugriff auf die Methoden und Eigenschaften des Objekts über die Variable $foo1.

Code:

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

Ausgabe:

Beispiel #3

Dies ist ein Beispiel für Methodenüberladung in der Programmiersprache PHP unter Verwendung der Funktion call() und privater/geschützter Methoden.

Hier erfolgt der Aufruf der privaten/geschützten Methoden durch den Zugriff durch Tippfehler oder ähnliches usw.

Echo _METHOD_PHP_EOL gibt zurück, welche Art von Methode verwendet wird. Es verwendet nur die Funktion _call(), die aus dem Objektkontext ausgeführt wird.

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();
?>

Ausgabe:

Beispiel #4

Dies ist das Programm der Funktionskonzepte call() und call static(), das für das Konzept der Methodenüberladung verwendet wird. Das folgende PHP-Programm ruft zuerst die Funktion _call() vor der Funktion _callstatic() in der Instanz auf.

Var dump() liefert Informationen über die Variable in der Klammer in PHP und einigen anderen objektorientierten Programmiersprachen. Ansonsten ist alles gleich, genau wie in den obigen Beispielen.

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();
?>

Ausgabe:

Beispiel #5

Dies ist das Beispiel der Funktion _call(); Wenn die Klasse des Objekts mit der Methode aufgerufen wird, die noch nicht einmal existiert, wird das Konzept der Funktion _call() anstelle der Methode aufgerufen.

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:

Das obige ist der detaillierte Inhalt vonMethodenüberladung in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!