Was ist Überladen in PHP?

Wir haben verschiedene Konzepte der objektorientierten Programmierung 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, mit der mehrere gleichnamige Methoden erstellt werden können, die sich in der Art der Eingabeparameter unterscheiden. Es wird einfach als die Fähigkeit einer Funktion definiert, verschiedene Aufgaben auszuführen.

Definition von Überladung in einer Zeile: „Gleicher Name, aber unterschiedliche Implementierungen“

Wie funktioniert das Überladen in PHP?

Wie wir wissen, wird die Methodenüberladung für Funktionen ausgeführt. Somit können Funktionen mit verschiedenen Implementierungen basierend auf den Argumenten, die an jede Funktion übergeben werden, überladen werden. Zum Beispiel, um die Fläche eines Kreises zu finden, der pi * r * r ist, wird der Radius angegeben, um die Fläche des Quadrats zu finden, die Seite * Seite ist, vorausgesetzt, die Länge der Seite wird angegeben, die Fläche eines Dreiecks ist (Basis * Höhe). / 2 vorausgesetzt die Basislänge und die Höhe sind angegeben und so weiter.

Overloading Concept erfordert Magic-Methoden.

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

Durch das Überladen werden dynamisch Eigenschaften und Methoden erstellt, die zusammen als Entitäten bezeichnet werden.

Die Entitäten werden auch als bezeichnet

  • Eigenschaften: Datenelemente
  • Methoden: Datenfunktionen

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

Im obigen Beispiel haben wir eine Klasse namens Test deklariert, die Privateigentum und eine __call-Methode hat. Zwei Argumente werden an die Methode __call übergeben. In der __call-Methode haben wir die Anweisung print () verwendet, ein var_dump, bei dem die Argumente und ein Wert x zurückgegeben werden.

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

Arten des Überladens in PHP

Es gibt zwei Arten des Überladens in PHP und wir wollen jeden Typ im Detail lernen.

  • Eigenschaftsüberladung
  • Methodenüberladung

1) Eigenschaftsüberladung

Durch das Überladen von Eigenschaften werden dynamische Eigenschaften erstellt, wenn das Objekt festgelegt wird. Diese Eigenschaft ist der Klasseninstanz zugeordnet. Wenn diese Eigenschaft nicht innerhalb der Klasse deklariert ist, wird sie als überladene Eigenschaft betrachtet. Dafür müssen Sie keinen zusätzlichen Code schreiben. Die folgenden magischen Methoden erzählen uns mehr darüber.

Nachfolgend sind Operationen aufgeführt, die mit überladenen Eigenschaften ausgeführt werden

Überladene Eigenschaften für Setter und Getter (mit __set () und __get ())

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

Rückgängigmachen solcher Einstellungen (mit __unset ())

Lassen Sie uns die Verwendung jeder dieser Methoden verstehen

Mit __set () => werden überladene Eigenschaften initialisiert.

Mit __get () => werden die bereits initialisierten Eigenschaften abgerufen

Mit __isset () => wird geprüft, ob die Eigenschaft gesetzt ist oder nicht

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

Mit __call () => werden überladene Methoden initialisiert

Mit __callStatic () => werden statische Methoden initialisiert

Alle obigen 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 "
". " 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:

Ausgabe

2) Methodenüberladung

Wie beim Überladen von Eigenschaften wird beim Überladen von Methoden eine dynamische Methode erstellt, die außerhalb der Klasse deklariert wird. Und dies 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 einer statischen Referenz verwendet

Das folgende Beispiel soll Ihnen helfen, mehr zu erfahren.

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

Ausgabe:

Regeln

1) Für die Überladungsmethoden wird der Public Access Specifier verwendet.

2) Der Überladungsprozess wird verwendet, bei dem beim Erstellen des Objekts der Klasse auf die Eigenschaften oder Methoden zugegriffen werden kann, die nicht innerhalb des Umfangs der Klasse definiert sind.

3) Magische Methoden werden zum Überladen von Eigenschaften oder Methoden verwendet. Von den beiden für Überladungsmethoden verwendeten magischen Methoden ist die im Objektkontext am häufigsten verwendete Methode die Methode __call () und die im statischen Kontext weniger verwendete Methode __callStatic ().

Empfohlener Artikel

Dies ist eine Anleitung zum Überladen in PHP. Hier diskutieren wir die Typen und das Konzept des Überladens in PHP mit den Beispielen. Sie können auch den folgenden Artikel lesen, um mehr zu erfahren -

  1. Was ist PHP?
  2. Was ist PHP Array?
  3. Core PHP Interview Fragen
  4. PHP-String-Funktionen
  5. Überladen in C # | Wie es funktioniert?
  6. Einführung in das Überladen in C ++
  7. Statische Methode in PHP
  8. Überladen und Überschreiben in C #
  9. Python Magic-Methode | Methoden, Komponenten (Beispiele)