Les appels de méthodes et l’accès aux membres peuvent être surchargés via les méthodes __call(), __get() et __set(). Ces méthodes ne seront déclenchées que si votre objet, hérité ou non, ne contient pas le membre ou la méthode auquel vous tentez d’accéder. Toutes les méthodes surchargées doivent être définies en tant que static. Toutes les méthodes surchargées doivent être définies en tant que public.

Depuis PHP 5.1.0, il est également possible de surcharger les fonctions isset() et unset() via, respectivement, les méthodes __isset et __unset.

void __set ( string name, mixed value ) mixed __get ( string name ) bool __isset ( string name ) void __unset ( string name )

Les membres d’une classe peuvent être surchargés afin d’exécuter un code spécial contenu dans vos méthodes __set() et __get(). Le paramètre “$name” est le nom de la variable qui doit être définie ou recherchée. Le paramètre “$valeur” de la méthode __set() spécifie la nouvelle valeur à donner à la variable “$name”.

<?php
class Setter 
{
  public $n;
  private $x = array("a" => 1, "b" => 2, "c" => 3);
 
  public function __get($nm) 
  {
    echo "Récupération de [$nm]\n";
 
    if (isset($this->x[$nm])) {
      $r = $this->x[$nm];
      echo "Retour : $r\n";
      return $r;
    } else {
      echo "Rien!\n";
    }
  }
 
  public function __set($nm, $val) 
  {
    echo "Définition de [$nm] à $val\n";
 
    if (isset($this->x[$nm])) {
      $this->x[$nm] = $val;
      echo "OK!\n";
    } else {
      echo "Pas OK!\n";
    }
   }
 
  public function __isset($nm)
  {
    echo "Vérifie si $nm est défini\n";
 
    return isset($this->x[$nm]);
  }
 
  public function __unset($nm)
  {
    echo "Libération de $nm\n";
 
    unset($this->x[$nm]);
  }
}
 
$foo = new Setter();
$foo->n = 1;
$foo->a = 100;
$foo->a++;
$foo->z++;
var_dump($foo);
 
var_dump(isset($foo->a)); //true
unset($foo->a);
var_dump(isset($foo->a)); //false
 
// ceci ne passera pas via la méthode __isset()
// parce que 'n' est une propriété publique
var_dump(isset($foo->n));
 
var_dump($foo);
?>

mixed __call ( string name, array arguments )

La méthode magique __call() permet de capture l’appel à des méthodes non existantes. De cette façon, __call() peut être utilisée pour implémenter un gestionnaire de méthodes défini par l’utilisateur qui dépend du nom de la méthode actuellement appelée. Ceci est particulièrement pratique pour implémenter un proxy, par exemple. Les arguments qui sont passés à la fonction devront être définis dans un tableau via le paramètre “$arguments”. La valeur retournée de la méthode __call() sera retournée à la méthode appelante.

Exemple 19-21. Exemple de surcharge avec __call

<?php
class Caller 
{
  private $x = array(1, 2, 3);
 
  public function __call($m, $a)
  {
    print "Méthode $m appelée :\n";
    var_dump($a);
    return $this->x;
  }
}
 
$foo = new Caller();
$a = $foo->test(1, "2", 3.4, true);
var_dump($a);
?>

L’exemple ci-dessus va afficher : Méthode test appelée :

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)
}