[SOLUCIONADO] Sobrecarga en PHP POO

[jcd]

Muy buenas, una vez pido ayuda en este foro que de tanto me ha servido anteriormente.

Primeramente gracias por adelantado para todo aquel que lea esto, que tengo que reconocer que es un poco aburrido y largo.

Esta vez tengo que reconocer que voy más perdido que otras veces, estoy empezando a hacer mis pinitos en POO y no entiendo el concepto de sobrecarga, sé que PHP no soporta la sobrecarga pero puede simularse, entiendo, o eso creo, el concepto de polimorfismo pero la sobrecarga me da problemas.

Quiero generar un método que dependiendo del número de parámetros que le pase me ejecuta uno u otro codigo, y quiero hacer 5 casos, si acepta dos parámetros, me da la suma, si acepta tres el producto, si acepta cuatro la suma 2 a 2 y la división...etc.

pero no entiendo varias cosas:
1) según mi codigo, en realidad estoy haciendo 5 métodos distintos con 5 nombres distinos, cuando lo que quiero es que se llamen igual.

2)se supone que cuando isntancie al método, en ese momento es cuando tengo que pasarle los parámetros, y dependiendo de cuántos sean me hará una u otra cosa.

3) pongo mi codigo, y me salta el siguiente error:
Fatal error: Call to undefined method miclase::metodo() in C:\xampp\htdocs\loader.php on line 47, no sé porque me lo llama comosi fuera estático.

os adjunto el codigo:

Código PHP:

<?php
class miclase{
$metodos = array();
public function _call($method_name,$parametros){
 
if(in_array($method_name,$this->metodos)){
if(func_num_args($parametros)==0){
$this-> metodo0;
}
if(func_num_args($parametros)==1){
$this-> metodo1;
}
if(func_num_args($parametros)==2){
$this-> metodo2;
}
if(func_num_args($parametros)==3){
$this-> metodo3;
}
if(func_num_args($parametros)==4){
$this-> metodo4;
}
if(func_num_args($parametros)==5){
$this-> metodo5;
}
}
 
else
{
echo "error, no existe el método";}
}
public function metodo1(){
return "hola";}
 
public function metodo2($num1){
return $num1;}
 
public function metodo3($num1,$num2){
return $num1 + $num2;}
public function metodo4($num1,$num2,$num3){
return $num1 * $num2 * $num3;}
 
public function metodo5($num1,$num2,$num3,$num4){
return ($num1 + $num2 )/($num3 + $num4);
}
}
$objeto = new miclase(3,5,6);
$objeto -> metodo();
?>
 

[dashtrash]

Iniciado por jcd

sé que PHP no soporta la sobrecarga pero puede simularse, entiendo, o eso creo, el concepto de polimorfismo pero la sobrecarga me da problemas.

Quiero generar un método que dependiendo del número de parámetros que le pase me ejecuta uno u otro codigo, y quiero hacer 5 casos, si acepta dos parámetros, me da la suma, si acepta tres el producto, si acepta cuatro la suma 2 a 2 y la división...etc.

Eso no es polimorfismo, y, por lo tanto, tampoco sobrecarga.Son distintos métodos que lo único que tienen que ver los unos con los otros, es que quieres que se llamen igual.
Sobrecarga es cuando quieres realizar la *misma* acción sobre diferentes tipos de datos, especialmente, cuando dichos tipos tienen una clase base común.Pero lo importante es que la acción sea semánticamente la misma.La suma, la división, la multiplicación, no son lo mismo.

Iniciado por jcd

1) según mi codigo, en realidad estoy haciendo 5 métodos distintos con 5 nombres distinos, cuando lo que quiero es que se llamen igual.

Según tu código, ya están en un método que se "llaman igual".. _call.

Iniciado por jcd

2)se supone que cuando isntancie al método, en ese momento es cuando tengo que pasarle los parámetros, y dependiendo de cuántos sean me hará una u otra cosa.

Y ese método..se llama "_call"

Iniciado por jcd

3) pongo mi codigo, y me salta el siguiente error:
Fatal error: Call to undefined method miclase::metodo() in C:\xampp\htdocs\loader.php on line 47, no sé porque me lo llama comosi fuera estático.

Porque en tu clase no está definido ese método.Te lo "llama como si fuera estático", porque en PHP no existen métodos de instancia, sólo métodos de clase.Así que, por convención, te lo escribe así.

Iniciado por jcd

Código PHP:

<?php
...
$this-> metodo0;
...
$this-> metodo1;
...
$this-> metodo2;
...
$this-> metodo3;
...
$this-> metodo4;
...
$this-> metodo5;
 

Esas líneas no creo que estén haciendo nada (digo creo, porque es posible que estén creando variables miembro..quién sabe)

[jcd]

ok, gracias, ahora empiezo a entenderlo, a ver si creo un mejor ejemplo para acabarlo de entender.

[jcd]

osea, polimorfismo es cuando un método ejecuta codigos distintos dependiendo de si los parámetros que se le pasan son distintos en número y/o en tipo.

y sobrecarga es cuando quiero que a un objeto se le aplique distintos métodos.

[dashtrash]

Sobrecarga es un tipo especial de polimorfismo, aplicado a operadores.PHP no soporta polimorfismo (ni sobrecarga) ya que es un lenguaje no tipado.
Supón que tienes un método Pagar() en una clase, y quieres poder pagar con monedas, con tarjeta, o con un cheque.Éste sería un caso válido para hacer versiones polimórficas de Pagar(Monedas monedas){} .. Pagar(Cheque cheque).. etc.
En PHP, este comportamiento lo construyes definiendo un solo método Pagar($medio), y haciendo is_a , get_class(), etc, para determinar el tipo del objeto que han pasado como parámetro, y derivar al método (privado) correspondiente (Pagar_cheque, Pagar_tarjeta, etc)

Por otro lado, hay que, aunque PHP no permite al programador sobrecargar operadores, el operador '+' funciona con diferentes tipos de datos (números, arrays), en algo muy parecido a lo que sería una sobrecarga de operador típica.

[portalmana]

PHP a partir de la versión 5 si soporta Polimorfismo, y se puede realizar sobrecarga pero no de una manera tan pura como otros lenguajes orientados a objetos.

Sobrecarga de Metodos

Saludos

[dashtrash]

Iniciado por portalmana

PHP a partir de la versión 5 si soporta Polimorfismo, y se puede realizar sobrecarga pero no de una manera tan pura como otros lenguajes orientados a objetos.

Sobrecarga de Metodos
Saludos

Donde dice , en ese link, que PHP 5 soporta polimorfismo!?! Y, por supuesto, mucho menos, sobrecarga de operadores.

Decir que el uso de los métodos mágicos de PHP significa que el lenguaje en sí soporta alguna característica...
Para esta "implementación no tan pura", no hacen falta métodos mágicos.

Código PHP:

function llamaALoQueYoQuiera($methodName,$args)
{
      if(method_exists(.....)
}
 

Con pasarle en $args los parámetros como un array...Puestos a no ser "puros"..

La interpretacion de PHP para la sobrecarga de métodos, es diferente a la mayoria de los lenguajes orientados a objetos

Y tan diferente.Es *ninguna*.No existe tal cosa como "la interpretacion de PHP para la sobrecarga de métodos".

Esté método puede ser redefinido para cubrir las necesidades del proyecto o como en este caso, proporcionar sobrecarga a nuestros scripts

Con lo que ya no es la "interpretacion de PHP", sino la "interpretación del proyecto"..Por dios, vaya blog...
_call puedes usarlo para hacer "sobrecarga"..
o "getters" y "setters"..
o funcionalidades de ORM..
o mil cosas..
Y no es ninguna de ellas.

[portalmana]

Manual de PHP eso para sobrecarga y creo que tienes mal el concepto de Polimorfismo si no te darías cuenta que php si soporta Polimorfismo.

Fijate que el enlace dice Sobrecarga de Métodos y no polimorfismo.

Saludos

[dashtrash]

Se invoca a los métodos de sobrecarga cuando se interactúa con propiedades o métodos que no se han declarado o que no son visibles en el ámbito activo.

Ahora ve a ***cualquier*** manual de orientación a objetos, y me dices qué tiene que ver la sobrecarga, con la visibilidad dentro de un ámbito.

Wikipedia:

In computer science, polymorphism is a programming language feature that allows values of different data types to be handled using a uniform interface.

Vaya, seguro que esto se parece mucho más a lo que vas a encontrar en cualquier manual de Java o C++.Pero , vaya, ni mención a la visibilidad.Es más, esta definición no tiene *NADA* que ver con lo mencionado en el manual.

Wikipedia, Function overload

Function overloading or method overloading is a feature found in various programming languages such as Ada, C++, C#, D, and Java, that allows creating several methods with the same name which differ from each other in the type of the input and the output of the function. It is simply defined as the ability of one function to perform different tasks.

Vaya, insisten en que lo que define la sobrecarga/polimorfismo, son 2 características:
1- Mismo nombre de método
2- Tipos de las variables de entrada
Sigue sin mencionar nada ni de que el método no exista, ni de la visibilidad de las variables..

Que puede, el **programador** hacer una implementación de "__call" que sirva para algo parecido a la sobrecarga? Si..y a mil cosas más...
Significa eso que el **lenguaje** tenga "soporte" de esas mil cosas...No..Significa que lo ha hecho el programador

Si yo hago una implementación de __call, para soportar getters y setters automáticos, esos getters y setters son "funciones sobrecargadas"?

[portalmana]

Haber si nos entendemos, si digo que php soporta de una manera no pura overloading significa que no es la manera ortodoxa que se conoce para un lenguaje orientado a objetos.

En el Manual lo aclara:
La interpretación de PHP de "overloading" es distinta de la mayoría de los lenguajes orientados a objetos. La sobrecarga tradicionalmente ofrece la capacidad de tener múltiples métodos con el mismo nombre, pero con un tipo o un número distinto de parámetros.

Polimorfismo no hay duda que si lo soporta.

saludos

P.D.: No se que te preocupo tanto que le contestara que si soporta Polimorfismo.
PHP a partir de la versión 5 si soporta Polimorfismo, y se puede realizar sobrecarga pero no de una manera tan pura como otros lenguajes orientados a objetos.

PHP es no tipado, pero para datos no nativos si se puede hacer que sea tipado.

Código PHP:

public function tipado(Usuario $user) ...
o incluso public function (array $usuarios) ....
No asi para integer, strings, booleanos y otros nativos..
 

En definitiva el hilo es la solución de la sobrecarga para quien pregunta y es como la resuelve el manual.

[dashtrash]

Iniciado por portalmana

Haber si nos entendemos, si digo que php soporta de una manera no pura overloading significa que no es la manera ortodoxa que se conoce para un lenguaje orientado a objetos.

Juas...Yo tengo un pato, pero le llamo "elefante no ortodoxo".

La interpretación de PHP de "overloading" es distinta de la mayoría de los lenguajes orientados a objetos.

PHP tiene toooda la libertad del mundo , de llamar "overloading" a lo que quiera, y decir que es "distinto su concepto".El pequeño problema es que OOP está inventado desde mucho antes que PHP, así como la idea de la sobrecarga.Si PHP quiere hacer "métodos que se llaman cuando no existe una función con un nombre", y le quiere llamar "overloading", pues eso, "elefante no ortodoxo".
Es más, PHP va más allá, y crea el "member overloading".Puedes hacer sobrecarga de variables miembro, sea lo que sea que eso signifique.Para eso, tiene los métodos mágicos __get y __set, también aplicados a cuando no existe una variable pública con ese nombre.

PFFFF.....

Iniciado por portalmana

Polimorfismo no hay duda que si lo soporta.

Ponme 1 ejemplo.

[portalmana]

Código PHP:

<?php
// Ejemplo Clasico de Polimorfismo en cualquier lenguaje
 
 
abstract class Figura
{ 
    abstract public function area();
    abstract public function perimetro();
}
 
class Cuadrado extends Figura
{
    public function area()
    {
        echo 'Area de un Cuadrado<br>';
    }
    
    public function perimetro()
    {
        echo 'Perimetro de un Cuadrado<br>' ;
    }
}
 
class Circulo extends Figura
{
    public function area()
    {
        echo 'Area de un Circulo<br>';
    }
    
    public function perimetro()
    {
        echo 'Perimetro de un Circulo<br>' ;
    }      
}
 
 
class Geometria
{
    
    private $_figura;
    
    public function __construct(Figura $figura)
    {
        $this->_figura = $figura;
    }
    
    public function calcular()
    {
        $this->_figura->area();
        $this->_figura->perimetro();
    }
}
 
$calc = new Geometria(new Circulo());
$calc->calcular();
 

[dashtrash]

Iniciado por portalmana

[HIGHLIGHT="PHP"]
<?php
// Ejemplo Clasico de Polimorfismo en cualquier lenguaje

"Ejemplo Clasico de Polimorfismooooo???""" Re - juas.Será que PHP tiene un "concepto poco ortodoxo del polimorfismo"...Pero...lo de "en cualquier lenguaje"....
Ahora resulta que derivacion == Polimorfismo..
(Amos...acceder a la clase derivada, a través de la signature de la clase base, y eso, si a PHP le importara un pimiento que
le pongas un type-hinting que para lo que vale es para los editores de texto...porque lo que es a él...)
Si es que no puede ser...

[portalmana]

http://msdn.microsoft.com/es-es/libr...=vs.90%29.aspx
http://materias.fi.uba.ar/7507/conte...limorfismo.pdf
http://cursos.aiu.edu/Lenguajes%20de.../Tema%204b.pdf

[dashtrash]

Ese tipo de polimorfismo, está relacionado con el tipado .. cosa que PHP ignora..Pero hay muchos otros tipos de polimorfismo que sí son soportados por lenguajes orientados a objetos:
http://en.wikipedia.org/wiki/Polymor...puter_science)

Desengañate..Lo único que soporta php es Duck typing

[portalmana]

PHP soporta por lo menos polimorfismo por herencia y por interfaces entonces tu no puedes decir que no lo soporta. Al dar una respuesta al que inicia el hilo debes de dar la forma de solucionar el problema.
Ese ejemplo es de los mas clásicos de polimorfismos y te lo enseñan en cualquier lenguaje poo.

Aparte te digo que te falta un poco de educación para contestar para ser colaborador, no se contesta ni con sarcasmos ni risitas ni nada de eso. Y no es dificil admitir que php si soporta polimorfismo por definicion.

En programación orientada a objetos el polimorfismo se refiere a la posibilidad de enviar un mensaje a un grupo de objetos cuya naturaleza puede ser heterogénea. El único requisito que deben cumplir los objetos que se utilizan de manera polimórfica es saber responder al mensaje que se les envía.

[jcd]

no llego a enterarme.

podeis ponerme un ejemplo de sobrecarga y otro de polimorfismo, el ejemplo de las áeras del circulo y cuadrado me parece un polimorfismo.

otro podía ser:

Código PHP:

<? php
class numeros{
public function polimorfica($num1,$num2){
if (is_string($num1,$num2)){ return $snum1 + $num2;}
elseif (is_string($num1,$num2)){return num1num2;}
else {return "error"}
?>
 

osea, un mismo método sobre los mismos objetos hace una u otra cosa según sea el tipo.

realmente habría que poner con and porque is_string se aplica a una variable no hay más de una pero por ahorrar escritura.

¿cierto?

[pfranco]

Estoy viendo que muchos de los que comentan no tienen claro conceptos básicos de polimorfismo. Les recomiendo que antes de asegurar cosas que puedan confundir al compañero que realizó una pregunta investiguen a cerca de los conceptos.

http://es.wikipedia.org/wiki/Polimor...orm%C3%A1tica)

[portalmana]

Este es un ejemplo de sobrecarga del Manual de PHP

Código PHP:

<?php
class SobreCarga
{
    public function __call($metodo, $parametros)
    {   if (method_exists($this, $metodo.sizeof($parametros))) return call_user_func_array(array($this, $metodo.sizeof($parametros)), $parametros);
                // Si la Funcion no Existe
                throw new Exception('Metodo Desconocido: '.get_class($this).'::'.$metodo);
        }
 
        function Param2($a, $b) {
                echo "<br />Param2($a,$b)\n";
        }
 
        function Param3($a, $b, $c) {
                echo "<br />Param3($a,$b,$c)\n";
        }
}
 
$o = new SobreCarga();
$o->Param(4,5);
$o->Param(4,5,6);
$o->ParamX(4,5,6,7);
?>
// La salida de este script seria:
Param2(4,5)
Param3(4,5,6)
Fatal error: Uncaught exception 'Exception' with message 'Metodo Desconocido: SobreCarga::ParamX' in C:\xampp\htdocs\buscadorFullText\buscadorFullText\SobreCarga.php:7 Stack trace: #0 C:\xampp\htdocs\buscadorFullText\buscadorFullText\SobreCarga.php(22): SobreCarga->__call('ParamX', Array) #1 C:\xampp\htdocs\buscadorFullText\buscadorFullText\SobreCarga.php(22): SobreCarga->ParamX(4, 5, 6, 7) #2 {main} thrown in C:\xampp\htdocs\buscadorFullText\buscadorFullText\SobreCarga.php on line 7
 

Si ves desde fuera de la clase, esta sobrecarga simula bastante la tradicional, es decir utilizas el mismo método con distintos parámetros y se ejecutan distintos métodos aunque si ves la implementación aquí es donde se ve que no es una implementación normal de sobrecarga. A esto es a lo que supongo que dice el manual de php que no es normal.

Saludos

[jcd]

Después de unos días he entendido los conceptos de Polimorfismo y Sobrecarga en PHP, y me estoy dando cuenta de que las respuestas que me disteis no eran muy buenas, puede que fuera porque quien respondía no sabía exactamente la verdad.

Polimorfismo:

......... Método que ejecuta rutinas diferentes según los atributos sobre los que actúa, es decir, un ,método (POO) o función a la que se le pueden pasar distintos grupos de parámetros tanto en número como en tipo , y según sean estos, hace una cosa u otra.

Sobrecarga:
......N métodos llamados igual (por ejemplo _call) que . actuando sobre el mismo grupo de atributos o parámetros ejecuta rutinas diferentes.

Ejemplo de Polimorfismo:

Código PHP:

<?php
error_reporting(E_ALL);
class poli{
public function ppp()
{
if (func_num_args()==0){
echo "mete algún parámetro macho, de lo contrario no hay nada con lo que trabajar";
}
if (func_num_args()==1){
      
      echo func_get_arg(0)."<br>";
                                    }
     
if( func_num_args()==2){
 
  if (is_string(func_get_arg(0)) && is_string(func_get_arg(1)))
       {
         echo "las entradas son cadenas de texto"."    ".func_get_arg(0)."    "."y"."    ".func_get_arg(1)."<br>";
          }
  elseif (is_numeric(func_get_arg(0)) && is_numeric(func_get_arg(1)))
       {
         echo "las entradas son números, cuya suma es:";
         echo func_get_arg(0) + func_get_arg(1) ."<br>";
       }
 
   else 
       {
          echo "ERROR, las variables ni son números ni cadenas";
        }
 
 
       }//termina el primer BUCLE
if (func_num_args()==3){
 if (is_string(func_get_arg(0)) && is_string(func_get_arg(1))&& is_string(func_get_arg(2)))
       {
         echo "las entradas son cadenas de texto"."    ".func_get_arg(0)."    "."y"."    ".func_get_arg(1)."    "."y".func_get_arg(2)."<br>";
          }
  elseif (is_numeric(func_get_arg(0)) && is_numeric(func_get_arg(1))&& is_numeric(func_get_arg(2)))
       {
         echo "las entradas son números, cuya suma es:";
         echo func_get_arg(0) + func_get_arg(1) - func_get_arg(2) ."<br>";
       }
 
   else 
       {
          echo "ERROR, las variables ni son números ni cadenas"."<br>";
        }
    }//termina el segundo bucle.
    if(func_num_args()>3){
    echo "CUIDADO RADIOACTIVOMAN El número de parámetros debe ser uno, dos o tres";
    echo "<br>";
    }//termina el último bucle.
 
}//termina la función
 
}//termina la clase
 
 
?>
 

se ejecuta :

Código PHP:

<html>
<head>
<title>polimorfismo</title>
</head>
<body>
<?php
require_once('polimorfismo1.php');
error_reporting(E_ALL);
$ob=new poli();
$ob->ppp("Hola me llamo Anita");
$ob->ppp(2.4);
$ob->ppp(3,2);
$ob->ppp("4","6");
$ob->ppp(4.4,6.7);
$ob->ppp(4,3,7);
$ob->ppp(4,5,6,7);
$ob->ppp(true,false);
$obect->ppp("2","hola");
?>
</body>
</html>
 

dependiendo del número de de parámetros hace una u otra cosa, y si el número de parámetros es igual pero de distinto tipo, también ejecutra rutinas diferentes.

Ejemplo de Sobrecarga conmétodo _call, (ejemplo sacado de Internet, enhorabuena a Carlos Gil Luna por su excelente ejemplo).

Código PHP:

<?php
class cochecito{
private $marca ;
private $color ;
private $pais ;
private $potencia;
private $vmax;
private $precio;
 
function __call($method, $arguments) {
$prefix = strtolower(substr($method, 0, 3));
$property = strtolower(substr($method, 3));
if (empty($prefix) || empty($property)) {
return;
}
if ($prefix == "get" && isset($this->$property)) {
return $this->$property;
}
if ($prefix == "set") {
$this->$property = $arguments[0];
}
}//fin del método
 
 
 } //fin de la clase.
?>
 

y lo ejecutamos:

Código PHP:

<?php
error_reporting(E_ALL);
require_once('onewhocalls.php');
?>
<html>
<head>
<title>probandometodomagicocall</title>
</head>
<body>
<?php
$one=new cochecito();
$one->setmarca("Ferrari");
$one->setmarca("Porche");
$one->setcolor("rojo");
$one->setprecio("160000/$");
echo "la marca del coche es:"."    ".$one->getmarca()."<br>";
echo "el color del coche es:"."     ".$one->getcolor()."<br>";
echo "el precio del capricho es:"."    ".$one->getprecio()."<br>";
?>
</body>
</html>
 

no existen los métodos set ni get pero, PHP en vez de dar error, al tener un _call declarado, va allí para ver qué pasa, y lo que pasa es que _Call le impide dar error obligandole a ejecutar una serie de rutinas que, basicamente son que si los tres primeras carácteres del método instanciado (que no existe) empiezan por set me haga un seteo, si empiezan por get y resulta que coincide con alguno de los atributos declarados, me imprima ese atributo, como vemos, N métodos distintos todos llamados _call que actuando sobre los mismos atributos me ejecutan codigos distintos.

[portalmana]

Revisa las definiciones que pusiste de Polimorfismo y sobrecarga.

Saludos

Esto es de la wiki:
Diferencias entre polimorfismo y sobrecarga

El polimorfismo como se muestra en el ejemplo anterior, suele ser bastante ventajoso aplicado desde las interfaces, ya que permite crear nuevos tipos sin necesidad de tocar las clases ya existentes (imaginemos que deseamos añadir una clase Multiplicar), basta con recompilar todo el código que incluye los nuevos tipos añadidos. Si se hubiera recurrido a la sobrecarga durante el diseño exigiría retocar la clase anteriormente creada al añadir la nueva operación Multiplicar, lo que además podría suponer revisar todo el código donde se instancia a la clase.

La sobrecarga se da siempre dentro de una sola clase, mientras que el polimorfismo se da entre clases distintas.

Un método está sobrecargado si dentro de una clase existen dos o más declaraciones de dicho método con el mismo nombre pero con parámetros distintos, por lo que no hay que confundirlo con polimorfismo.

En definitiva: La sobrecarga se resuelve en tiempo de compilación utilizando los nombres de los métodos y los tipos de sus parámetros; el polimorfismo se resuelve en tiempo de ejecución del programa, esto es, mientras se ejecuta, en función de la clase a la que pertenece el objeto.

[jcd]

polimorfismo se puede dar sólo en una clase, aquí es cada web tiene una definción distinta, yo creo que es como decía yo,pero tampoco soy un maestro así que....

[jcd]

ah no, que me estoy liando, confundí polimorfismo con sobrecarga, más o menos es como yo decía pero cambiando las definiciones

[dashtrash]

Iniciado por portalmana

PHP soporta por lo menos polimorfismo por herencia y por interfaces entonces tu no puedes decir que no lo soporta. Al dar una respuesta al que inicia el hilo debes de dar la forma de solucionar el problema.
Ese ejemplo es de los mas clásicos de polimorfismos y te lo enseñan en cualquier lenguaje poo.

Aparte te digo que te falta un poco de educación para contestar para ser colaborador, no se contesta ni con sarcasmos ni risitas ni nada de eso. Y no es dificil admitir que php si soporta polimorfismo por definicion.

Me parece bien..en esas acepciones de polimorfismo..Te las acepto..Aunque yo a eso siempre le he llamado sobreescritura de métodos (method overriding), que es, además, el keyword que utilizan varios lenguajes de programación para indicarlo.
Sobre las risitas y el sarcasmo...lo siento, cuando alguien sostiene que PHP soporta sobrecarga, porque tiene el método _call, se le demuestra varias veces con distintos argumentos que eso no es así, y aún así se insiste...Sale de natural.

Ves? Yo no tengo problema en admitir que php soporta polimorfismo (aunque no sea mi terminología, entiendo que para mucha gente sí lo es)...

Aparte, la solución al problema la dí en el segundo post del thread.