Vergleich zweier Versionen der objektorientierten Methodenüberladung von PHP

Mehrere Funktionen verwenden denselben Namen, aber die Parameterliste, dh die Anzahl der Parameter oder (und) der Datentyp, kann unterschiedlich sein. Beim Aufruf kann die entsprechende Funktion automatisch aufgerufen werden, obwohl der Methodenname identisch ist entsprechend der Parameterliste aufgerufen.
PHP4 implementiert nur einige einfache objektorientierte Funktionen, während die Unterstützung von PHP5 für Objekte in Zukunft viel leistungsfähiger sein wird.
Für die polymorphe Implementierung unterstützt PHP4 nur Override, aber keine Überladung. Aber wir können einige Tricks anwenden, um die Implementierung der Überladung zu „simulieren“.
Obwohl PHP5 Überschreiben und Überladen unterstützen kann, unterscheidet sich die spezifische Implementierung der Überladung immer noch deutlich von anderen Sprachen.
1. Überladung in PHP4 „simulieren“

Versuchen Sie den folgenden Code:

//Wählen Sie die Ausführung verschiedener Methoden entsprechend der Anzahl der Parameter (in PHP4 „Überladung“ simulieren (eine Art Polymorphismus)

class Myclass
{
function Myclass()
{
$method = "func_num_args( <🎜". >$this->$method();
}

function method1($x)

{
echo "method1"

function method2($x, $y)

{

echo 'method2'
}
}

//Verwenden Sie diese Klasse durch zusätzliche Verarbeitung in der Klasse. Transparent für Benutzer:

$obj1 = new Myclass('A'); //Methode1 wird aufgerufen

$obj2 = new Myclass('B','C'); //Methode2 wird aufgerufen
?>

Im obigen Code können wir durch die Verwendung der Funktion func_num_args() im Konstruktor, um die Anzahl der Parameter abzurufen, die Methode method1 oder method2 automatisch ausführen. Wir können die Funktionen func_get_arg(i) und func_get_args() kombinieren. . Verbessern Sie das obige Beispiel

2, verwenden Sie Überladung in PHP5

Schauen Sie sich zunächst das folgende Beispiel an:

Kopieren Sie den Code wie folgt:

< ?php
class Myclass
{
public $attriable;
public $one = "this is one"
public $two = "this is two";

function __construct()

{

}

function one($one)

{

$this->one=$one;
$this->attriable = $this->one;
}

function one($one, $two)

{

$this->one=$one; >two=$two;
$this->attriable = $this->one
>
function display()
{
echo $this->attriable; myclass = new myclass();

$myclass->one($one);

$myclass->display();

$myclass->one($one, $ two);
$myclass->display();

//Der Ansatz in diesem Beispiel ist in PHP falsch!

?>


Personen, die C++-, Java- und C#-Überladungen verwendet haben, sind daran gewöhnt, den PHP-Code für die oben genannte Überladungsimplementierung zu schreiben. Dies gilt jedoch nicht für PHP5. PHP5 ist keine Nachahmung der oben genannten Sprachen, sondern verfügt über einen eigenen Satz von Methoden zur Implementierung von Methodenüberladung (ob sie gut oder schlecht ist, wird hier nicht diskutiert). Obwohl die Klassen von PHP5 viel leistungsfähiger sind als die von PHP4, wurde das Problem der „Überladung“ nicht wie erwartet „verbessert“. „Überladen“ kann durch verschiedene Parametertypen in „stark“ typisierten Sprachen wie C++, Java, C# usw. erreicht werden. In Sprachen, in denen „feste Parameter“ übergeben werden, kann auch die Anzahl der Parameter übergeben werden, wie z. B. Java, aber PHP ist eine schwach typisierte Sprache, sodass es nicht zu einer „Überladung“ wie oben kommt.

Überladen in PHP5 kann durch mehrere spezielle Methoden __get, __set und __call durchgeführt werden. PHP ruft diese Methoden auf, wenn die Zend-Engine versucht, auf ein Mitglied zuzugreifen und es nicht finden kann.

Im folgenden Beispiel ersetzen __get und __set alle Zugriffe auf das Attributvariablen-Array. Bei Bedarf können Sie auch jede gewünschte Filterart implementieren. Beispielsweise kann ein Skript das Festlegen von Eigenschaftswerten deaktivieren, mit einem bestimmten Präfix beginnen oder einen bestimmten Werttyp einschließen. Die Methode __call veranschaulicht, wie Sie eine undefinierte Methode aufrufen können. Wenn Sie eine undefinierte Methode aufrufen, werden der Methodenname und die von der Methode empfangenen Parameter an die Methode __call übergeben, und PHP gibt den Wert von __call an die undefinierte Methode zurück.

Der Code lautet wie folgt:

class Overloader
{

private $properties = array();

function __get ($property_name )

{

if(isset($this->properties[$property_name]))

{
return($this->properties[$property_name]);
}
else
{
return(NULL>); -> Properties[$property_name] = $value;

public function __call($method, $p)
{
print("Aufruf von $method()
n"); 🎜>//print_r($args);
if($method == 'display')
{
if(is_object($p[0]))
$this->displayObject ($p[0]);
else
if(is_array($p[0]))
$this->displayArray($p[0]);
else
$this->displayScalar($p[0]);
}
}

public function displayObject($p)

{

echo („Was Sie übergeben haben, ist ein Objekt, der Inhalt ist wie folgt:
");
print_r($p);
echo "

---

";
}

public function displayArray( $p)

{

echo ("Was Sie übergeben haben, ist ein Array mit dem folgenden Inhalt:
");
print_r($p);
echo "

---

";
}

public function displayScalar($p)

{

echo ("Was Sie übergeben haben, ist eine separate Variable mit folgendem Inhalt:
" . $p );
echo "< ;hr>";
}

$o = new Overloader();

//Rufen Sie __set() auf, um einen zuzuweisen Wert zu einer nicht vorhandenen Attributvariablen

$o->dynaProp = "Dynamic Content";

//Call __get()
print($o->dynaProp . "< br>n");

//Call __call()
//$o->dynaMethod("Leon", "Zeev");

$o-> display(array(1,2, 3));
$o->display('Cat');

?>

Im obigen Code ist die Methode display() aufgerufen, der anhand der Art und Anzahl der Parameter bestimmt werden kann. Rufen Sie das entsprechende Codesegment in der Klasse auf, um die Überladung der Objektmethode zu realisieren.

Vielen Dank fürs Lesen. Wenn Sie weitere verwandte Inhalte wünschen, schauen Sie sich bitte die chinesische PHP-Website (www.php.cn) an!