no se puede definir el constructor como protegido o privado. ¿por qué?

Question

--- A.php ---- 
require_once 'B.php'; 

class A 
{ 
    public function __constructor($x){...} 

    public function foo() 
    { 
     $b = B::getInstance(); 
     ... 
    } 
} 

--- B.php ---- 
require_once 'A.php'; 

class B extends A 
{ 
    protected static $_instance = null; 

    protected function __construct(){} 

    public static function getInstance() 
    {....} 
} 

PHP sólo se detiene interpretar el código tan pronto como se alcanza la línea de

protected function __construct(){} 

y da salida a todo antes y nada de lo que habría sido enviada al navegador después.

Y tan pronto como me tomo esa línea, cambiándola a

// protected function __construct(){} 

todo funciona bien !?

No entiendo eso.

¿Alguna idea?

Answer 1

Acabo de crear un archivo de prueba simple para confirmar si esto sucede en mi máquina también, y creo que he encontrado la respuesta. Tomemos el siguiente código:

<?php 
error_reporting(E_ALL | E_STRICT); 
class Foo { 
    public function __construct() { 
    } 
} 

class Bar extends Foo { 
    protected function __construct() { 
    } 
} 

, se intenta ejecutar ese código, me sale un error fatal: "PHP Fatal error: Nivel de acceso a Bar :: __ construct() debe ser público (como en la clase Foo) en/home/berry/foo.php en la línea 12. " Eso significa que no puede cambiar el nivel de acceso en una clase secundaria, si el padre ya ha definido el nivel de acceso, lo que realmente tiene mucho sentido: PHP no sabría a qué constructor llamar, supongo.

Como nota al margen: al mirar su código, B se extiende A, y A usa B. ¿Por qué exactamente es así, me parece una construcción extraña? Supongo que realmente quieres es composition, not inheritance.

Answer 2

Usted puede definir un constructor como protegido o privado. Este código se compila runs just fine since OOP was rewritten for PHP/5:

<?php 

class A{ 
    public function __construct(){ 
     echo 'Instance of A created' . PHP_EOL; 
    } 
} 

class B{ 
    protected function __construct(){ 
     echo 'Instance of B created' . PHP_EOL; 
    } 
} 

class C{ 
    private function __construct(){ 
     echo 'Instance of C created' . PHP_EOL; 
    } 
} 

Por supuesto, los constructores privados que impiden la creación de una instancia con la palabra clave new, pero PHP desencadenará un error fatal (que no sólo dejarán de publicarse):

<?php 

new A; // OK 
new B; // Fatal error: Call to protected B::__construct() from invalid context 
new C; // Fatal error: Call to private C::__construct() from invalid context 

Answer 3

puede crear iniciadores estáticas personalizadas:

<?php 

class FancyClass { 
    public static function init() { 
     new self(); 
    } 

    protected function __construct() { 
     echo 'Instance created!'; 
    } 
} 

# This will not work. 
new FancyClass(); 

# But this will work. 
FancyClass::init();