Sobrecarga de métodos

Ya hemos hablado anteriormente de los métodos con significados especiales (métodos mágicos) cuyos nombres empezaban por un doble guión bajo ( \_\_ ), como por ejemplo _\__get()_, _\__set()_, _\__construct()_ y _\__destruct()_. Otro ejemplo es el método **\_\_call()** , que se utiliza en PHP para implementar la sobrecarga de métodos. La sobrecarga de métodos es habitual en muchos lenguajes orientados a objetos pero en PHP no resulta demasiado útil ya que en su lugar se suelen utilizar tipos flexibles y los parámetros opcionales de las funciones.

Este método se ejecuta automáticamente cuando se intenta invocar a un método que no es accesible o no existe. Como parámetros, recibe el nombre del método invocado (**$fName**) y un vector con los argumentos que se pasaron en la llamada (**$fArgs**).

Otra utilidad es que nos permitirá sobrecargar métodos con el mismo nombre y diferente signatura que analizaremos a través de la matriz de argumentos.

Aquí vemos un ejemplo de un clase que implementa la sobrecarga de métodos mediante __call:

<?php
   class ejemploCall {
      function __call ( $fName, $fArgs) {
         switch($fName) {
            case 'sum':
               if (count ($fArgs) === 1) {
                  return $fArgs[0];
               }
               else {
                  $retVal = 0;
                  foreach( $fArgs as $arg ) {
                     $retVal += $arg;
                  }
                  return $retVal;
               }
               break;
            case 'pow':
               if ((count ($fArgs) === 1) && (count($fArgs) == 2)) {
                  return $fArgs[0]; //devolvemos el primer argumento
               }
               else {
                  $retVal = pow($fArgs[0], $fArgs[1]) ;
                  return $retVal;
               }
               break;
            default:
               die ('<div><>Fatal Error:</b> metodo ' .
               $fName . ' no conocido en la clase ' . __CLASS__ . '.</div>');
         } // end switch
      }
   }
   $obj = new ejemploCall();
   // llamada implicita a $obj->__call('sum', 4). Devuelve 4
   echo $obj->sum(4);
   // llamada implicita a $obj->__call('sum', 4, 5). Devuelve 9
   echo $obj->sum(4, 5);
   // llamada implicita a $obj->__call('pow', 2, 5). Devuelve 32
   echo $obj->pow(2,5);
   // metodo no conocido
   echo $obj->res(4, 5);
?>

Del ejemplo podemos destacar el error fatal que lanzamos sino existe el método al que invocamos ($obj->res)

El inconveniente de este método mágico es la ofuscación del código.