Überladung in PHP

Wir haben verschiedene objektorientierte Programmierkonzepte wie Klasse, Objekt, Kapselung, Polymorphismus usw. in PHP. Überladen ist auch ein solches Konzept von OOPs in PHP. Funktionsüberladung oder Methodenüberladung ist eine Funktion, die das Erstellen mehrerer Methoden mit demselben Namen ermöglicht, die sich in der Art der Eingabeparameter voneinander unterscheiden. Es wird einfach als die Fähigkeit einer Funktion definiert, verschiedene Aufgaben auszuführen.

Definition der Überladung in einer Zeile: „gleicher Name, aber unterschiedliche Implementierungen.“

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Wie funktioniert Überladen in PHP?

Wie wir wissen, wird Methodenüberladung bei Funktionen durchgeführt. Daher können Funktionen basierend auf den an jede Funktion übergebenen Argumenten mit unterschiedlichen Implementierungen überladen werden. Um zum Beispiel die Fläche eines Kreises zu ermitteln, die pi *r *r ist, sofern der Radius angegeben ist, um die Fläche eines Quadrats zu ermitteln, die Seite * Seite ist, vorausgesetzt, dass die Länge einer Seite angegeben ist, beträgt die Fläche eines Dreiecks (Basis). * Höhe) / 2 vorausgesetzt die Basislänge und die Höhe sind angegeben und so weiter.

Überladungskonzept erfordert magische Methoden.

Magic Methods beginnt mit __ (doppelter Unterstrich) und wird von PHP automatisch aufgerufen. Außerdem werden diese immer innerhalb der Klasse und nicht außerhalb der Klasse definiert. Verschiedene magische Methoden sind __get(), __set,__construct(), __destruct(), __call(), __callStatic(), __isset(), __unset(),

Wenn das Überladen durchgeführt wird, werden Eigenschaften und Methoden dynamisch erstellt, die zusammen als Entitäten bezeichnet werden.

Die Entitäten werden auch als

• Eigenschaften: Datenelemente
• Methoden: Datenfunktionen

Sehen wir uns an, wie die Magic-Methode mit der __call()-Methode funktioniert

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

Im obigen Beispiel haben wir eine Klasse namens Test deklariert, die über eine private Eigenschaft und eine __call-Methode verfügt. Zwei Argumente werden an die __call-Methode übergeben. Innerhalb der __call-Methode haben wir die Anweisung print(), einen var_dump der Argumente und einen Rückgabewert x verwendet.

Dann wird das Objekt der Klasse mit dem Namen obj erstellt und mit diesem Objekt wird eine undefinierte Methode aufgerufen, da diese Methode nicht existiert. Stattdessen wird __call() aufgerufen.

Arten der Überladung in PHP

Es gibt zwei Arten der Überladung in PHP. Lassen Sie uns jeden Typ im Detail lernen.

• Eigenschaftsüberladung
• Methodenüberladung

1) Eigentumsüberladung

Eigenschaftsüberladung erzeugt dynamische Eigenschaften, wenn das Objekt festgelegt wird. Diese Eigenschaft ist mit der Klasseninstanz verknüpft. Wenn diese Eigenschaft nicht im Umfang der Klasse deklariert ist, wird sie als überladene Eigenschaft betrachtet. Hierfür müssen Sie keinen zusätzlichen Code schreiben. Die folgenden magischen Methoden verraten uns mehr darüber.

Im Folgenden werden Vorgänge aufgeführt, die mit überladenen Eigenschaften ausgeführt werden

Setter- und Getter-überladene Eigenschaften (mit __set() und __get())

Auswerten der Einstellung für überladene Eigenschaften (mit __isset())

Diese Eigenschaftseinstellung rückgängig machen (mit __unset())

Lassen Sie uns die Verwendung jeder dieser Methoden verstehen

__set() => wird verwendet, um überladene Eigenschaften zu initialisieren.

__get() => wird verwendet, um die bereits initialisierten Eigenschaften abzurufen

__isset() => wird verwendet, um zu überprüfen, ob die Eigenschaft festgelegt ist oder nicht

__unset() => wird verwendet, um die Eigenschaft zu deaktivieren.

__call() => wird verwendet, um überladene Methoden zu initialisieren

__callStatic() => wird verwendet, um statische Methoden zu initialisieren

Alle oben genannten Methoden zusammen werden im folgenden Beispiel verwendet.

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:

Ausgabe

2) Methodenüberladung

Wie die Überladung von Eigenschaften erstellt auch die Überladung von Methoden eine dynamische Methode, die außerhalb des Klassenbereichs deklariert wird. Und das ist mit den magischen Methoden __call() und __callStatic() möglich. Diese werden basierend auf der Objektreferenz bzw. der statischen Referenz verwendet.

__call() -> wird zum Aufrufen überladener Methoden in der Objektreferenz verwendet

__callStatic() -> wird zum Aufrufen überladener Methoden in statischen Referenzen verwendet

Das folgende Beispiel wird Ihnen helfen, mehr zu erfahren.

<?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:

Ausgabe:

Regeln

1) Der öffentliche Zugriffsspezifizierer wird für die Überladungsmethoden verwendet.

2) Der Überladungsprozess wird verwendet, wobei bei der Erstellung des Objekts der Klasse auf Eigenschaften oder Methoden zugegriffen werden kann, die nicht im Umfang der Klasse definiert sind.

3) Magische Methoden werden zum Überladen von Eigenschaften oder Methoden verwendet. Von den beiden magischen Methoden, die zum Überladen von Methoden verwendet werden, ist die Methode __call() im Objektkontext die am häufigsten verwendete Methode, und die am wenigsten verwendete Methode ist die Methode __callStatic(), die im statischen Kontext verwendet wird.

Empfohlener Artikel

Dies ist eine Anleitung zum Überladen in PHP. Hier besprechen wir die Typen und das Konzept der Überladung in PHP anhand von Beispielen. Sie können sich auch den folgenden Artikel ansehen, um mehr zu erfahren –

1. Was ist ein PHP-Array?
2. Überladung in C#
3. Überladung in C++
4. Überladen und Überschreiben in C#

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