polimorfismo - sobrecarga de constructores php7

¿Por qué no puedo sobrecargar constructores en PHP?

Question

He abandonado toda esperanza de poder sobrecargar mis constructores en PHP, así que lo que realmente me gustaría saber es por qué .

¿Hay incluso una razón para eso? ¿Crea código intrínsecamente malo? ¿Es el diseño del lenguaje ampliamente aceptado no permitirlo, o hay otros lenguajes más agradables que PHP?

Answer 1

Creo que también podemos usar el constructor con argumentos predeterminados como un posible sustituto de la sobrecarga del constructor en PHP.

Aún así, es realmente triste que la verdadera sobrecarga de constructores no sea compatible con PHP.

Answer 2

La verdadera sobrecarga no es compatible en PHP. Como se menciona @Pestilence, puede usar argumentos variables. Algunas personas simplemente usan una matriz asociativa de varias opciones para superar esto.

Answer 3

No se puede sobrecargar ningún método en PHP. Si desea poder instanciar un objeto PHP mientras pasa varias combinaciones diferentes de parámetros, use el patrón de fábrica con un constructor privado.

Por ejemplo:

public MyClass {
    private function __construct() {
    ...
    }

    public static function makeNewWithParameterA($paramA) {
        $obj = new MyClass(); 
        // other initialization
        return $obj;
    }

    public static function makeNewWithParametersBandC($paramB, $paramC) {
        $obj = new MyClass(); 
        // other initialization
        return $obj;
    }
}

$myObject = MyClass::makeNewWithParameterA("foo");
$anotherObject = MyClass::makeNewWithParametersBandC("bar", 3);

Answer 4

Para completar, sugeriré interfaces fluidas . La idea es que agregando return $this; al final de sus métodos, puede encadenar llamadas. Entonces, en lugar de

$car1 = new Car(''blue'', ''RWD'');
$car2 = new Car(''Ford'', ''300hp'');

(que simplemente no funcionaría), puedes hacer:

$car = (new Car)
       ->setColor(''blue'')
       ->setMake(''Ford'')
       ->setDrive(''FWD'');

De esta forma puede elegir exactamente qué propiedades desea establecer. En muchos sentidos, es similar a pasar una serie de opciones a su llamada inicial:

$car = new Car([''make'' => ''Ford'', ''seats'' => 5]);

Answer 5

Por lo que sé, la sobrecarga de constructores en PHP no está permitida, simplemente porque los desarrolladores de PHP no incluyeron esa funcionalidad, esta es una de las muchas quejas sobre PHP.

He oído hablar de trucos y soluciones, pero la verdadera sobrecarga en el sentido de OOP no se encuentra. Tal vez en futuras versiones, se incluirá.

Answer 6

Puede usar argumentos variables para producir el mismo efecto. Sin un tipado fuerte, no tiene mucho sentido agregar, dados los argumentos predeterminados y todos los otros "problemas".

Answer 7

Puede usar declaraciones condicionales en su constructor y luego realizar su tarea. P.ej.

  class Example
  {
      function __construct($no_of_args)

      {// lets assume 2
          switch($no_of_args)
          {
              case 1:
                // write your code
              break;
              case 2:
                //write your 2nd set of code
              break;
              default:
           //write your default statement
         }
      }
   }

    $object1 = new Example(1);  // this will run your 1st case
    $object2 = new Example(2);  // this will run your 2nd case

y así...

Answer 8

Realmente no soy un experto en OOP, pero como entiendo, la sobrecarga significa la habilidad de un método para actuar de manera diferente dependiendo de los parámetros que recibe como entrada. Esto es muy posible con PHP, simplemente no declaras los tipos de entrada ya que PHP no tiene un tipado fuerte, y toda la sobrecarga se realiza en tiempo de ejecución en lugar de en tiempo de compilación.

Answer 9

ellos dicen este trabajo:

<?php
class A
{
    function __construct()
    {
        $a = func_get_args();
        $i = func_num_args();
        if (method_exists($this,$f=''__construct''.$i)) {
            call_user_func_array(array($this,$f),$a);
        }
    }

    function __construct1($a1)
    {
        echo(''__construct with 1 param called: ''.$a1.PHP_EOL);
    }

    function __construct2($a1,$a2)
    {
        echo(''__construct with 2 params called: ''.$a1.'',''.$a2.PHP_EOL);
    }

    function __construct3($a1,$a2,$a3)
    {
        echo(''__construct with 3 params called: ''.$a1.'',''.$a2.'',''.$a3.PHP_EOL);
    }
}
$o = new A(''sheep'');
$o = new A(''sheep'',''cat'');
$o = new A(''sheep'',''cat'',''dog'');

// results:
// __construct with 1 param called: sheep
// __construct with 2 params called: sheep,cat
// __construct with 3 params called: sheep,cat,dog
?>

y, parece que todos están contentos con eso, pero para mí no funcionó ... si logras que funcione, también es un tipo de sobrecarga ...

toma todos los argoments y los pasa al constructor secundario de funciones ...

Answer 10

Manual de PHP: Argumentos de funciones, valores predeterminados

He superado esto simplemente al usar valores predeterminados para los parámetros de la función. En __constuct , enumere primero los parámetros requeridos. Enumere los parámetros opcionales después de eso en la forma general $param = null .

class User
{
    private $db;
    private $userInput;

    public function __construct(Database $db, array $userInput = null)
    {
        $this->db = $db;
        $this->userInput = $userInput;
    }
}

Esto puede ser instanciado como:

$user = new User($db)

o

$user = new User($db, $inputArray);

Esta no es una solución perfecta, pero he hecho esto para separar los parámetros en parámetros absolutamente obligatorios sin importar cuándo se construye el objeto y, como grupo, los parámetros opcionales enumerados en orden de importancia .

Funciona.

Answer 11

<?php
//php do not automatically call parent class constructor at all if child class has constructor so you have to call parent class constructor explicitly, however parent class constructor is called automatically if child class has no constructor
class MyClass 
{
    function construct1($value1)
    {
        echo "<br/> dummy constructor is called with 1 arguments and it is $value1";
    }
    function construct2($value1,$value2)
    {
        echo "<br/> dummy constructor is called with 2 arguments and it is $value1, $value2";
    }
    function construct3($value1,$value2,$value3)
    {
        echo "<br/> dummy constructor is called with 3 arguments and it is $value1, $value2 , $value3";
    } 
    public function __construct()
    {
        $NoOfArguments = func_num_args(); //return no of arguments passed in function
        $arguments = func_get_args();
        echo "<br/> child constructor is called $NoOfArguments";
        switch ($NoOfArguments) {
            case 1:
                 self::construct1($arguments[0]);
                break;
            case 2:
                self::construct2($arguments[0],$arguments[1]);
                break;

            case 3:
                self::construct3($arguments[0],$arguments[1],$arguments[2]);
                break;

            default:
                echo "Invalid No of arguments passed";
                break;
        }
    }


}
$c = new MyClass();
$c2 = new MyClass("ankit");
$c2 = new MyClass("ankit","Jiya");
$c2 = new MyClass("ankit","Jiya","Kasish");

?>