APORTE: Emular polimorfismo y sobrecarga tipada de forma simple.

[lolainas]

Buen aporte amigo, me gusta la idea.

Apuntes:

1. chk_polimorfismo debería devolver el resultado de la ejecución del método sobrecargado.

2. Uso de métodos mágicos de PHP, en concreto '__call', imaginate en un proyecto grande llamando a

Código PHP:

Customer->sobrecarga('getLastOrder', array('param1', 'param2', 'param3'), true, true);
 

3. Aprovecha la reflexión para solucionar este problema:

Código PHP:

<?php
 
abstract class Overridable extends \ReflectionObject {
 
    private function compare(array $params, array $args) {
        if (count($params) != count($args))
            return false;
        foreach ($params as $param)
            if ($param->getName() != gettype(each($args)[1]))
                return false;
        return true;
    }
 
    function __construct() {
        parent::__construct($this);
    }
 
    function __call($name, $args) {
        foreach ($this->getMethods() as $method)
            if (strpos($method->getShortName(), $name) === 0 && $this->compare($method->getParameters(), $args))
                return call_user_func_array([$this, $method->getName()], $args);
        throw new \ReflectionException;
    }
 
}
 
class Test extends Overridable {
 
    protected function method0($integer) {
        var_dump(__METHOD__, "Hola, has ingresado: '$integer'");
    }
 
    protected function method1($string) {
        var_dump(__METHOD__, "Hola, has ingresado: '$string'");
    }
 
    protected function method2($integer, $string) {
        var_dump(__METHOD__, "Hola, has ingresado: '$integer' y '$string'");
    }
 
    protected function method3($string, $integer) {
        var_dump(__METHOD__, "Hola, has ingresado: '$string' y '$integer'");
    }
 
}
 
$test = new Test;
 
$test->method(1);
$test->method('hola');
$test->method(99, 'hola');
$test->method('hola', 1);
 

Esto es un aporte a tu aporte, no existe ni mejor ni peor solución, sólo diferentes y me parecía excesivo abrir un tema cuando justo estábamos desarrollando algo parecido cada uno para sus diferentes fines.