Sowohl Methodenaufrufe als auch Zugriffe auf Member können mittels der
__call, __get und __set Methoden überladen werden. Diese Methoden werden
nur ausgelöst, wenn Ihr Objekt oder abgeleitetes Objekt den Member oder
die Methode, auf die Sie zuzugreifen versuchen, nicht enthält.
Keine Überladungsmethode darf
statisch definiert sein.
In PHP 5.0.x müssen alle Überladungsmethoden als
public definiert sein.
Seit PHP 5.1.0 ist es ebenfalls möglich, die Funktionen
isset() und unset() mittels der
jeweiligen Methoden __isset und __unset zu überladen.
void
__set ( string name, mixed value )
mixed
__get ( string name )
bool
__isset ( string name )
void
__unset ( string name )
Klassenmember können überladen werden, um eigenen in Ihrer Klasse
definierten Code auszuführen, indem man diese speziell benannten
Methoden definiert. Der Parameter $name ist der Name
der Variablen, die gesetzt oder zurückgeliefert werden soll.
Der Parameter $value der __set() Methode spezifiziert
den Wert, den das Objekt der Variable $name zuweisen
soll.
Beispiel 19-19. Beispiel für Überladung mit __get(), __set(), __isset() und __unset()
<?php
class Setter
{
public $n;
private $x = array("a" => 1, "b" => 2, "c" => 3);
public function __get($nm)
{
echo "Liefere [$nm]\n";
if (isset($this->x[$nm])) {
$r = $this->x[$nm];
echo "Gebe zurück: $r\n";
return $r;
} else {
echo "Nichts!\n";
}
}
public function __set($nm, $val)
{
print "Setze [$nm] auf $val\n";
if (isset($this->x[$nm])) {
$this->x[$nm] = $val;
echo "OK!\n";
} else {
echo "Nicht OK!\n";
}
}
private function __isset($nm)
{
echo "Prüfe, ob $nm gesetzt ist\n";
return isset($this->x[$nm]);
}
private function __unset($nm)
{
echo "Lösche $nm\n";
unset($this->x[$nm]);
}
}
$foo = new Setter();
$foo->n = 1;
$foo->a = 100;
$foo->a++;
$foo->z++;
var_dump(isset($foo->a)); //true
unset($foo->a);
var_dump(isset($foo->a)); //false
// Dies wird nicht an die Methode __isset() übergeben,
// weil 'n' eine public Eigenschaft ist
var_dump(isset($foo->n));
var_dump($foo);
?>
|
Das oben gezeigte Beispiel erzeugt folgende
Ausgabe:
Setze [a] auf 100
OK!
Liefere [a]
Gebe zurück: 100
Setze [a] auf 101
OK!
Liefere [z]
Nichts!
Setze [z] auf 1
Nicht OK!
Prüfe, ob a gesetzt ist
bool(true)
Lösche a
Prüfe, ob a gesetzt ist
bool(false)
bool(true)
object(Setter)#1 (2) {
["n"]=>
int(1)
["x:private"]=>
array(2) {
["b"]=>
int(2)
["c"]=>
int(3)
}
}
|
|
mixed
__call ( string name, array arguments )
Klassenmethoden können überladen werden, um eigenen in Ihrer Klasse
definierten Code auszuführen, indem man diese speziell benannte
Methode definiert. Der $name Parameter ist der Name
der Funktion, deren Benutzung angefordert wurde. Die Argumente, die der
Funktion übergeben wurden, werden als ein Array im $arguments
Parameter definiert. Der von der __call() Methode zurückgegebene Wert wird
dem Aufrufer der Methode zurückgegeben.
Beispiel 19-20. Beispiel für Überladung mit __call
<?php
class Caller
{
private $x = array(1, 2, 3);
private function __call($m, $a)
{
print "Methode $m aufgerufen:\n";
var_dump($a);
return $this->x;
}
}
$foo = new Caller();
$a = $foo->test(1, "2", 3.4, true);
var_dump($a);
?>
|
Das oben gezeigte Beispiel erzeugt folgende
Ausgabe:
Methode test aufgerufen:
array(4) {
[0]=>
int(1)
[1]=>
string(1) "2"
[2]=>
float(3.4)
[3]=>
bool(true)
}
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
|
|