(PHP 5, PHP 7)

ReflectionClass::isInstantiableVérifie si une classe est instanciable


public bool ReflectionClass::isInstantiable ( void )

Vérifie si une classe est instanciable.


Cette fonction n'est pas documentée et seule la liste des arguments est disponible.

Liste de paramètres

Cette fonction ne contient aucun paramètre.

Valeurs de retour

Cette fonction retourne TRUE en cas de succès ou FALSE si une erreur survient.


Exemple #1 Exemple avec ReflectionClass::isInstantiable()

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);
"Est-ce que la classe $class est instanciable  ?  ";


L'exemple ci-dessus va afficher :

Est-ce que la classe C est instanciable  ?  bool(true)
Est-ce que la classe iface est instanciable  ?  bool(false)
Est-ce que la classe ifaceImpl est instanciable  ?  bool(true)
Est-ce que la classe abstractClass est instanciable  ?  bool(false)
Est-ce que la classe D est instanciable  ?  bool(true)
Is privateConstructor instantiable?  bool(false)

Voir aussi

add a note add a note

User Contributed Notes 1 note

shaun at slickdesign dot com dot au
2 days 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