ReflectionClass::isInstantiable

(PHP 5, PHP 7)

ReflectionClass::isInstantiableComprueba si una clase es instanciable

Descripción

public bool ReflectionClass::isInstantiable ( void )

Comprueba si una clase es instanciable.

Parámetros

Esta función no tiene parámetros.

Valores devueltos

Devuelve TRUE en caso de éxito o FALSE en caso de error.

Ejemplos

Ejemplo #1 Ejemplo de ReflectionClass::isInstantiable()

<?php
class { }

interface 
ifaz {
    function 
f1();
}

class 
ifazImpl implements ifaz {
    function 
f1() {}
}

abstract class 
claseAbstracta {
    function 
f1() { }
    abstract function 
f2();
}

class 
extends claseAbstracta {
    function 
f2() { }
}

class 
constructorPrivado {
    private function 
__construct() { }
}

$clases = array(
    
"C",
    
"ifaz",
    
"ifazImpl",
    
"claseAbstracta",
    
"D",
    
"constructorPrivado",
);

foreach(
$clases  as $clase ) {
    
$reflectionClass = new ReflectionClass($clase);
    echo 
"¿Es instanciable la clase $clase?  ";
    
var_dump($reflectionClass->IsInstantiable()); 
}

?>

El resultado del ejemplo sería:

¿Es instanciable la clase C?  bool(true)
¿Es instanciable la clase ifaz?  bool(false)
¿Es instanciable la clase ifazImpl?  bool(true)
¿Es instanciable la clase claseAbstracta?  bool(false)
¿Es instanciable la clase D?  bool(true)
¿Es instanciable la clase constructorPrivado?  bool(false)

Ver también

add a note add a note

User Contributed Notes 1 note

up
0
shaun at slickdesign dot com dot au
1 month ago
An example missing from the documentation is that `ReflectionClass::isInstantiable` will also return false for traits, as well as interfaces and abstract classes.

<?php
trait t {
   
// Optional trait methods and properties etc.
}

$reflectionClass = new ReflectionClass("t");
var_dump($reflectionClass->isInstantiable()); // bool(false)
?>

As for classes with private constructors, it is still possible to create an instance by either bypassing the constructor using `ReflectionClass::newInstanceWithoutConstructor`, or by ensuring the class has a method which can create a new instance.

<?php
class p {
    private function
__construct() {
       
// Optional constructor logic - not called when ReflectionClass::newInstanceWithoutConstructor is used.
   
}

    public static function
create() {
        return new
p;
    }

   
// Optional methods and properties etc.
}

// Class is not classed as instantiable.
$reflectionClass = new ReflectionClass("p");
var_dump($reflectionClass->isInstantiable()); // bool(false)

// We're still able to create an instance using one of the two methods.
$p = p::create();
$p = $reflectionClass->newInstanceWithoutConstructor();
?>

The same is also true for protected constructors, however, the class can be instantiated from either parent or child methods, depending on where the constructor is defined.

<?php
class p {
    protected function
__construct() {
       
// Optional constructor logic.
   
}

    public static function
create( $class = "" ) {
        if (!
$class) {
           
$class = get_called_class();
        }
        return new
$class;
    }

   
// Optional parent methods and properties etc.
}

class
c extends p
{
   
// Optional child methods and properties etc.
}

// Both child and parent static methods have access to each other's protected constructor.
$p = c::create("p");
$c = p::create("c");

// Both are still not classed as being instantiable.
$reflectionClassP = new ReflectionClass("p");
$reflectionClassC = new ReflectionClass("c");
var_dump($reflectionClassP->isInstantiable()); // bool(false)
var_dump($reflectionClassC->isInstantiable()); // bool(false)

// We're still able to bypass the constructor and create an instance for each.
$p = $reflectionClassP->newInstanceWithoutConstructor();
$c = $reflectionClassC->newInstanceWithoutConstructor();
?>
To Top