PHP 7.2.7 Released


(PHP 5)

ReflectionClass::isInstantiableChecks if the class is instantiable


public bool ReflectionClass::isInstantiable ( void )

Checks if the class is instantiable.

Elenco dei parametri

Questa funzione non contiene parametri.

Valori restituiti

Restituisce TRUE in caso di successo, FALSE in caso di fallimento.


Example #1 ReflectionClass::isInstantiable() example

class { }

iface {

ifaceImpl implements iface {
f1() {}

abstract class 
abstractClass {
f1() { }
    abstract function 

extends abstractClass {
f2() { }

privateConstructor {
    private function 
__construct() { }

$classes = array(

$classes  as $class ) {
$reflectionClass = new ReflectionClass($class);
"Is $class instantiable?  ";


Il precedente esempio visualizzerĂ :

Is C instantiable?  bool(true)
Is iface instantiable?  bool(false)
Is ifaceImpl instantiable?  bool(true)
Is abstractClass instantiable?  bool(false)
Is D instantiable?  bool(true)
Is privateConstructor instantiable?  bool(false)

Vedere anche:

add a note add a note

User Contributed Notes 1 note

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

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.

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

    public static function
create() {
        return new

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

class p {
    protected function
__construct() {
// Optional constructor logic.

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

// Optional parent methods and properties etc.

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