APORTE: Emular polimorfismo y sobrecarga tipada de forma simple.

[NSD]

Hola gente, arme este humilde script que utiliza la herencia de una clase generica llamada polimorfismo para realizar este proceso y lo comparto por si alguien le interesa.

se puede sobrecargar por cantidad de argumentos, por cantidad y tipo, por cantidad, tipo y clase (si el parametro es un objeto).

aqui el codigo:

Código PHP:

<?php
 // Clase padre heredable, es la que realiza la emulacion.
 class polimorfismo
 {
    /*
     * @param string $metodo        El nombre del metodo que se va a sobrecargar.
     * @param array  $params        Los parametros con los que se llamo el metodo.
     * @param bool   $tipado        Indica si se va a discriminar por el tipo de los argumentos.
     * @param bool   $instanciado   Indica si se va a discriminar por el tipo de clase de los parametros (cuando sea un objeto).
    */
    protected function chk_polimorfismo($metodo, $params, $tipado = false, $instanciado = false)
    {
        $metodo .= count($params);
        if($tipado && $params)
        {
            foreach($params as $param)
                $metodo .= '_'.(gettype($param) == 'object' ? ($instanciado ? get_class($param) : 'object') : gettype($param));
        }
        
        if(method_exists($this, $metodo))
            call_user_func_array(array($this,$metodo),$params);
    }   
 }
 
 // Las clases que emulen el polimorfismo deben heredar.
 class test_polimorfico extends polimorfismo
 {
    // Al metodo publico a sobrecargar, se le asigna la llamada al metodo protected de la clase emuladora.
    public function sobrecargado() { $this->chk_polimorfismo('test', func_get_args(), true); }  
    
    // Se crean los metodos protected que seran llamados por la sobrecarga.
    // Se los pone como protected para que no sean vistos desde afuera y simulen un polimorfismo mas clasico.
    protected function test0() // 0 argumentos.
    {
        echo('<br>Hola, no me pasaron ningun parametro.');
    }
    
    protected function test1_string($string) // Un argumento, de tipo string
    {
        echo('<br>Hola, me pasaste este string: '.$string);
    }
    
    protected function test1_integer($integer) // Un argumento, de tipo integer
    {
        echo('<br>Hola, me pasaste este integer: '.$integer);
    }
    
    protected function test2_integer_string($integer, $string)
    {
        echo('<br>Hola, me pasaste este integer: '.$integer.' y este string: '.$string);
    }
    
    protected function test2_string_integer($string, $integer)
    {
        echo('<br>Hola, me pasaste este string: '.$integer.' y este integer: '.$string);
    }
 }
 
 $test = new test_polimorfico();
 $test->sobrecargado();
 $test->sobrecargado('prueba');
 $test->sobrecargado(5);
 $test->sobrecargado(5, 'prueba');
 $test->sobrecargado('prueba', 5);
 $test->sobrecargado('2');
 

[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.

[lolainas]

Me gustaría agregar, si no te importa, que el título del post puede confundir y mucho, una cosa es la sobrecarga de métodos y otra el polimorfismo, el polimorfismo basicamente es que un objeto puede adquirir muchas (poli) formas (morfi), un ejemplo básico de polimorfismo:

Código PHP:

<?php
 
interface Vehicle {
    function run();
}
 
class Train implements Vehicle {
    function run() {
        echo 'chu-chu, chu-chu, chu-chu, ...<br />';
    }
}
 
class Car implements Vehicle {
    function run() {
        echo 'run, run, run, run, ...<br />';
    }
}
 
class Human {
    function drive(Vehicle $vehicle) {
        $vehicle->run();
    }
}
 
(new Human)->drive(new Car);
(new Human)->drive(new Train);
 

Creo que cabe aclararlo. Saludos.

[NSD]

La sobrecarga es una implementacion del polimorfismo, asi como el ejemplo que tu propones es otra forma de implementarlo. El polimorfismo es un concepto abstracto no ligado a una forma de implementarlo.

Bueno, me has sorprendido con la clase abstracta, no me lo esperaba.
Fucione tu codigo y el mio (junto con un par de agregados) y mira lo que salio ¡Se puede usar el polimorfismo como en java! (o casi igual)

Código PHP:

<?php
 abstract class OverridableType extends \ReflectionObject
 {
     public static function handleTypehint($errno, $errstr, $errfile, $errline)
     {      
        if (!(error_reporting() & $errno)) { return; }      
        if ($errno == E_RECOVERABLE_ERROR)
        {
            if (preg_match('/^Argument (\d)+ passed to (?:(\w+)::)?(\w+)\(\) must be an instance of (\w+)(.*)/', $errstr, $errmatches))
                return true;
        }
        return false;
     }
 
    function __construct() { parent::__construct($this); set_error_handler('OverridableType::handleTypehint'); }
 
    function __call($name, $args)
    {
        $cant_args = count($args);
 
        if($cant_args)
        {
            foreach ($this->getMethods() as $method)
            {
                $parameters = $method->getParameters();
                if(count($parameters) == $cant_args) // Misma cantidad de parametros.
                {
                    preg_match("/^$name([0-9]+)/", $method->getShortName(), $coincidencias);
                    if($coincidencias)
                    {
                        // Tienen el mismo numero de argumentos, y el nombre del metodo coincide.
                        preg_match_all('|Parameter #[0-9]+ \[ (<required>*) (.*) \$(.*) \]|U', $method->getParameters()[0]->getDeclaringFunction(), $params);
 
                        $coincidencia = true;
                        foreach($params[2] as $nro => $param)
                        {
                            $type = gettype($args[$nro]);
                            // Verificar que sean del mismo tipo.
                            if(!($type == $param) and !($type == 'object' && ($args[$nro] instanceof $param)))
                            {
                                $coincidencia = false;
                                break;
                            }
                        }
                        if($coincidencia)
                            return call_user_func_array([$this, $method->getShortName()], $args);
                    }
                }
            }
        } else {
            // No vienen parametros. Caso particular.
            return call_user_func_array([$this, $name], $args);
        }
    }
 }
 

Código PHP:

<?php
// Y asi es como se implementa.
 interface Vehicle {
     function run();
 }
 
 class Train implements Vehicle {
    function run() {
        echo 'chu-chu, chu-chu, chu-chu, ...<br />';
    }
 }
 
 class Car implements Vehicle {
     function run() {
         echo 'run, run, run, run, ...<br />';
     }
 }
 
 class Moto implements Vehicle {
     function run() {
         echo 'rrrrrrrrrrrrrrrrrrrr ...<br />';
     }
 }
 
 class Foto {
     function sepia() {
         echo 'me volvi sepia...<br />';
     }
 }
 
 class Test extends OverridableType
 {
    protected function method()
    {
         echo("<br>Hola, no has ingresado nada<br>");
    }
 
    protected function method1(integer $unNumero)
    {
         echo("<br>Hola, has ingresado: $unNumero<br>");
    }
 
    protected function method2(string $miString)
    {
        echo("<br>Hola, has ingresado: '$miString'<br>");
    }
 
    protected function method3(Train $unTren)
    {
        echo("<br>Hola, gracias por el tren<br>");
        $unTren->run();
    }
 
    protected function method4(Car $unAuto)
    {
        echo("<br>Hola, gracias por el auto<br>");
        $unAuto->run();
    }
 
    protected function method5(Vehicle $unVehiculo)
    {
        echo("<br>Hola, gracias por el vehiculo<br>");
        $unVehiculo->run();
    }
 
    protected function method6(object $unObjeto)
    {
        echo("<br>Hola, me diste un objeto: ".get_class($unObjeto).", muchas gracias.<br>");
    }
 }
 
 $test = new Test;
 
 $test->method();
 $test->method(1);
 $test->method('hola');
 $test->method(99, 'hola');
 $test->method('hola', 1);
 $test->method(new Car);
 $test->method(new Train);
 $test->method(new Moto);
 $test->method(new Foto);
 

[lolainas]

Me gusta!, aunque te has complicado un poco con el tema errores, en principio las clases no deben manejar errores, deben lanzar excepciones, precisamente por eso extiendo de ReflectionObject, captar los errores sería tan sencillo como usar un bloque try-catch y atrapar ReflectionException's, la clase en principio la he escrito pensando utilizarla mas o menos así:

Código PHP:

try {
    $test = new Test;
    $test->method(1);
    $test->method('hola');
    $test->method(99, 'hola');
    $test->method('hola', 1);
}
catch (\ReflectionException $ex) {
    echo $ex->getMessage();
    //La aplicación sigue viva y sé lo que está pasando
    //Está pasando que el metodo no existe...
    //puedo actuar en consecuencia...
}
 

Saludos.

[NSD]

El problema esta en el casting a tipos nativos que no esta soportado por php, es por eso que se incorpora el handler de errores, sin embargo este solo permite el paso de ese error de casting particular. por lo que el bloque try catch que tu propones, sigue siendo necesario.

[lolainas]

Si tuviese ese problema me pasaría a JSP o ASP (por ejemplo) y dejaría PHP para otra cosa...

[hhs]

Creo que el titulo debio decir algo como "Simulación de Polimorfismo estatico en lenguajes no tipificados" .

El aporte como experimento o simulación es interesante, pero no usaría algo que no implementa el lenguaje como una característica inherente a el. El polimorfismo estático es común en lenguajes tipificados como java, php no lo es. Si quieres "sobrecarga de métodos" generalmente se hace usando parametros por default: http://www.php.net/manual/en/functions.arguments.php o con arreglos.

El problema esta en el casting a tipos nativos que no esta soportado por php, es por eso que se incorpora el handler de errores, sin embargo este solo permite el paso de ese error de casting particular. por lo que el bloque try catch que tu propones, sigue siendo necesario.

El problema es que quieres usar un lenguaje como si fuera otro. Cada lenguaje tiene sus propias características, ventajas y desventajas. Simular características que no son del lenguaje, puede ser el primer paso al desastre.
Si quieres probar algo sobre control de tipos de datos en php puedes usar estas clases experimentales: http://www.php.net/manual/en/book.spl-types.php O esperar a que algunas de las siguientes propuestas se implementen en el lenguaje: https://wiki.php.net/rfc/typechecking.

En general puedes sobrevivir sin la sobrecarga de métodos, pero si tu problema realmente lo requiere de la forma que lo hace java, entonces tu lenguaje es otro.

Por ultimo creo que tu aporte no funcionaria del todo bien cuando usas otra clase que herede a Test. Fuera de eso es ingenioso el artificio.

[NSD]

Bueno, veo que hubo varias sugerencias y criticas constructivas sobre esto, asi que aqui publico la nueva version que contempla todo lo que se planteo, y ademas, esta optimizada en comparacion a la anterior, la van a encontrar bastante flexible, aqui esta:

Código PHP:

<?php
 namespace NS;
  
 class OverridableType extends \ReflectionObject
 {
    private $overload = array();
    private static $overloadStatic = array();
 
    public function __construct()
    {
        parent::__construct($this);
 
        foreach ($this->getMethods() as $method)
        {
            $info = array_filter(array_map(function($val)
                                            {
                                                $filter = trim(trim($val, '/*'));
                                                return ($filter ? explode(" ", $filter) : null);
                                            }, explode("\n", $method->getDocComment())));
            if($info)
            {
                $tmp = array("params" => array());
                foreach($info as $directive)
                {
                    switch($directive[0])
                    {
                        case "@overload" : $tmp["method"]   = $directive[1]; break;
                        case "@count"    : $tmp["count"]    = $directive[1]; break;
                        case "@param"    : $tmp["params"][] = strtolower($directive[1]); break;
                        case "@default"  : $tmp["default"]  = $directive[1]; break;
                    }
                }
 
                if($method->isStatic())
                {
                    if($tmp["default"])
                    {
                        if($tmp["count"])
                            self::$overloadStatic[get_called_class()][$tmp["method"]][$tmp["count"]]["default"] = $tmp["default"];
                        else
                           self::$overloadStatic[get_called_class()][$tmp["method"]]["default"] = $tmp["default"];
                    } else
                        self::$overloadStatic[get_called_class()][$tmp["method"]][$tmp["count"]][] = array("types" => $tmp["params"], "name" => $method->getShortName());
                } else {
                    if($tmp["default"])
                    {
                        if($tmp["count"])
                            $this->overload[$tmp["method"]][$tmp["count"]]["default"] = $tmp["default"];
                        else
                            $this->overload[$tmp["method"]]["default"] = $tmp["default"];
                    }
                    else
                        $this->overload[$tmp["method"]][$tmp["count"]][] = array("types" => $tmp["params"], "name" => $method->getShortName());
                }
            }
        }
    }
 
    private static function getNameOverload($name, $args, $map)
    {
        if(isset($map[$name]))
        {
            $cant = count($args);
            if(isset($map[$name][$cant]))
            {
                foreach($map[$name][$cant] as $nro => $method)
                {
                    if($nro !== "default")
                    {
                        $match = true;
                        foreach($method["types"] as $tnro => $type)
                        {
                            $argType = gettype($args[$tnro]);
                            if(!($argType == $type) and !($argType == 'object' && ($args[$tnro] instanceof $type)))
                            {
                                $match = false;
                                break;
                            }
                        }
                        if($match)
                            return $method["name"];
                    }
                }                
                if(isset($map[$name][$cant]["default"]))
                    return $map[$name][$cant]["default"];
                else
                    die("No se pudo resolver el metodo $name con $cant argumentos tipados ".implode(", ",array_map(function($val) { return gettype($val); }, $args)).".");             
            } elseif(isset($map["default"]))
                return $map["default"];
            else
                die("No se pudo resolver el metodo $name con $cant argumentos."); 
        } else
            die("No se pudo resolver el metodo $name."); 
    }
 
    function __call($name, $args)
    {
        return call_user_func_array([$this, self::getNameOverload($name, $args, $this->overload)], $args);
    }
 
    function __callStatic($name, $args)
    {
        return forward_static_call([$this, self::getNameOverload($name, $args, self::$overloadStatic[get_called_class()])], $args);
    }
 }
 
 // Y asi es como se implementa.
 interface Vehicle 
 {
     function run();
 }
 
 namespace NSA;
 
 class Train implements \NS\Vehicle {
    function run() {
        echo 'chu-chua, chu-chua, chu-chua, ...<br />';
    }
 }
 
 namespace NSB;
 
 class Train implements \NS\Vehicle {
    function run() {
        echo 'chu-chub, chu-chub, chu-chub, ...<br />';
    }
 }
 
 namespace NS;
 
 class Car implements Vehicle {
     function run() {
         echo 'run, run, run, run, ...<br />';
     }
 }
 
 class Moto implements Vehicle {
     function run() {
         echo 'rrrrrrrrrrrrrrrrrrrr ...<br />';
     }
 }
 
 class Foto {
     function sepia() {
         echo 'me volvi sepia...<br />';
     }
 }
 
 class Test extends OverridableType
 {
    /**
      @overload miMetodo
      @count 0
    */
    public static function smethod()
    {
         echo("<br>Hola, no has ingresado nada de forma estatica<br>");
    }
    
    /**
      @overload miMetodo
      @count 1
      @param integer
    */
    public static function smethod1()
    {
         echo("<br>Hola, has ingresado: $unNumero estaticamente<br>");
    }
 
    /**
      @overload miMetodo
      @count 0
    */
    public function method()
    {
         echo("<br>Hola, no has ingresado nada<br>");
    }
 
    /**
      @overload miMetodo
      @count 1
      @param integer
    */
    public function method1($unNumero)
    {
         echo("<br>Hola, has ingresado: $unNumero<br>");
    }
 
    /**
      @overload miMetodo
      @count 1
      @param string
    */
    public function method2($miString)
    {
        echo("<br>Hola, has ingresado: '$miString'<br>");
    }
 
    /**
      @overload miMetodo
      @count 1
      @param Train
    */
    public function method3($unTren)
    {
        echo("<br>Hola, gracias por el tren<br>");
        $unTren->run();
    }
    
    /**
      @overload miMetodo
      @count 1
      @param NSA\Train
    */
    public function method3a($unTren)
    {
        echo("<br>Hola, gracias por el tren del namespace a<br>");
        $unTren->run();
    }
    
    /**
      @overload miMetodo
      @count 1
      @param NSB\Train
    */
    public function method3b($unTren)
    {
        echo("<br>Hola, gracias por el tren del namespace b<br>");
        $unTren->run();
    }
 
    /**
      @overload miMetodo
      @count 1
      @param NS\Car
    */
    public function method4($unAuto)
    {
        echo("<br>Hola, gracias por el auto<br>");
        $unAuto->run();
    }
 
    /**
      @overload miMetodo
      @count 1
      @param NS\Vehicle
    */
    public function method5($unVehiculo)
    {
        echo("<br>Hola, gracias por el vehiculo<br>");
        $unVehiculo->run();
    }
 
    /**
      @overload miMetodo
      @count 1
      @param Object
    */
    public function method6($unObjeto)
    {
        echo("<br>Hola, me diste un objeto: ".get_class($unObjeto).", muchas gracias.<br>");
    }
 
    /**
      @overload miMetodo
      @count 2
      @param integer
      @param string
    */
    public function method7($unNumero, $miString)
    {
         echo("<br>Hola, has ingresado un numero: $unNumero y un string '$miString'<br>");
    }
 
    /**
      @overload miMetodo
      @count 2
      @param string
      @param integer
    */
    public function method8($miString, $unNumero)
    {
        echo("<br>Hola, has ingresado un string: '$miString' y un numero $unNumero<br>");
    }
    
    /**
      @overload miMetodo
      @count 2
      @param integer
      @param integer
    */
    public function method9($unNumero, $otroNumero)
    {
        echo("<br>Hola, has ingresado un numero: $unNumero y un numero $otroNumero<br>");
    }
 }
 
 class Testb extends Test
 {    
    /**
      @overload miMetodo
      @count 2
      @param string
      @param integer
    */
    public function method8($miString, $unNumero)
    {
        echo("<br>Hola, has ingresado un string: '$miString' y un numero $unNumero pero en una subclase.<br>");
    }
 }
 
 $test = new Test;
 
 $test->miMetodo();
 $test->miMetodo(1);
 $test::miMetodo();
 $test::miMetodo(1);
 $test->miMetodo('hola');
 $test->miMetodo(99, 'hola');
 $test->miMetodo('hola', 1);
 $test->miMetodo(1, 2);
 $test->miMetodo(new Car);
 $test->miMetodo(new \NSA\Train);
 $test->miMetodo(new \NSB\Train);
 $test->miMetodo(new Moto);
 $test->miMetodo(new Foto);
 
 $testb = new Testb;
 $testb->miMetodo('hola', 1);
 

produce esta salida:

Hola, no has ingresado nada

Hola, has ingresado: 1

Hola, has ingresado: 'hola'

Hola, has ingresado un numero: 99 y un string 'hola'

Hola, has ingresado un string: 'hola' y un numero 1

Hola, has ingresado un numero: 1 y un numero 2

Hola, gracias por el auto
run, run, run, run, ...

Hola, gracias por el tren del namespace a
chu-chua, chu-chua, chu-chua, ...

Hola, gracias por el tren del namespace b
chu-chub, chu-chub, chu-chub, ...

Hola, gracias por el vehiculo
rrrrrrrrrrrrrrrrrrrr ...

Hola, me diste un objeto: NS\Foto, muchas gracias.

Hola, has ingresado un string: 'hola' y un numero 1 pero en una subclase.

[dashtrash]

Esta implementación está bastante mejor a nivel de funcionalidad.En los tests que incluyes creo que no hay gestión de parámetros opcionales, que creo que sí está intentando gestionar el código.
No soy un fan de meter código en los comentarios (aunque ese código no sea php), pero el código está más limpio que antes, y soporta más cosas.

[Italico76]

@NSD : se ve interesante pero genera muchos Warnings y Notices en PHP 5.4.26 :

Warning: The magic method __callStatic() must have public visibility and be static in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 101

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 36

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 36

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Hola, no has ingresado nada

Hola, has ingresado: 1

Notice: Undefined variable: this in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 103

Warning: forward_static_call() expects parameter 1 to be a valid callback, first array member is not a valid class name or object in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 103

Notice: Undefined variable: this in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 103

Warning: forward_static_call() expects parameter 1 to be a valid callback, first array member is not a valid class name or object in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 103

Hola, has ingresado: 'hola'

Hola, has ingresado un numero: 99 y un string 'hola'

Hola, has ingresado un string: 'hola' y un numero 1

Hola, has ingresado un numero: 1 y un numero 2

Hola, gracias por el auto
run, run, run, run, ...

Hola, gracias por el tren del namespace a
chu-chua, chu-chua, chu-chua, ...

Hola, gracias por el tren del namespace b
chu-chub, chu-chub, chu-chub, ...

Hola, gracias por el vehiculo
rrrrrrrrrrrrrrrrrrrr ...

Hola, me diste un objeto: NS\Foto, muchas gracias.

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 36

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 36

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Notice: Undefined index: default in C:\WWW\apache2\htdocs\pruebas\polimorfismo con ReflectionObject.php on line 45

Hola, has ingresado un string: 'hola' y un numero 1 pero en una subclase.

[NSD]

Gracias Italico76 y dashtrash, cuando tenga unos ratos libres movere el codigo a github y vere de ampliarlo un poco mas y aplicar las sugerencias, intentare tambien evitar el uso de reflection, que a mi gusto personal es lo que no me convence para aplicar esta clase en un entorno real, ya que se esta pagando con rendimiento una caracteristica que no es del todo necesaria.

Luego pongo el link aqui, saludos.

[hhs]

Antes de comentar, necesito saber algo NSD. Que es lo que soluciona tu aporte y como es que esperas que funcione en entornos reales ??

Iniciado por NSD

Intentare tambien evitar el uso de reflection, que a mi gusto personal es lo que no me convence para aplicar esta clase en un entorno real, ya que se esta pagando con rendimiento una caracteristica que no es del todo necesaria.

Luego pongo el link aqui, saludos.

No es la reflexión, aun que prescindas de ella tu solución seguira limitada.

[NSD]

Que es lo que soluciona tu aporte y como es que esperas que funcione en entornos reales ??

No soluciona nada, solo emula una característica que hace mas amigable el lenguaje de cara al programador, no pretende solucionar a ningun problema, como bien tu dijiste:

En general puedes sobrevivir sin la sobrecarga de métodos, pero si tu problema realmente lo requiere de la forma que lo hace java, entonces tu lenguaje es otro.

Y la verdad, no pretendo que funcione en entornos reales, un cambio de este tipo deberia ser implementado en el nucleo de php, es decir en C, no con una clase php.
Si buscas en la web experimentos CSS3 encontraras muchas cosas interesantes pero de discutible aplicacion practica, sin embargo de php no hay tanta variedad, esto no es mas que eso, un pequeño experimento que puede servir con fines didacticos, o como una curiosidad, es responsabilidad de cada programador saber aplicarlo en un entorno real. Con saber que se puede, y que alguien lo hizo y que esta disponible para cuando lo necesites (si es que llega ese dia) es suficiente, no ambiciono a nada mas, ni siquiera a que alguien la use.

[asus090102]

Uaaaauuuuuu, me siento como un mono tratando de entender porque le llama la atención que un rayo haya incendiado un árbol.
Sin ningún tipo de comprensión de que es el fuego en realidad, o el árbol, y el rayo obviamente menos que menos.
Creo que me voy a dedicar a estudiar papel mache, jajajajajaja.

[NSD]

Por si a alguien le interesa, dejo el link a github donde esta alojado esto y donde apareceran nuevas versiones, si existen. https://github.com/Proyecto-NSD/PHP-overload

[awik]

vaya , solo habia visto esto hace tiempo pero con java ..no sabia q tambien lo habia en PHP