ReflectionClass::isInstantiable()
(PHP 5, PHP 7)
检查类是否可实例化
说明
public ReflectionClass::isInstantiable(void): bool
检查这个类是否可实例化。
参数
此函数没有参数。
返回值
成功时返回TRUE
,或者在失败时返回FALSE
。
范例
Example #1ReflectionClass::isInstantiable()例子
<?php class C { } interface iface { function f1(); } class ifaceImpl implements iface { function f1() {} } abstract class abstractClass { function f1() { } abstract function f2(); } class D extends abstractClass { function f2() { } } class privateConstructor { private function __construct() { } } $classes = array( "C", "iface", "ifaceImpl", "abstractClass", "D", "privateConstructor", ); foreach($classes as $class ) { $reflectionClass = new ReflectionClass($class); echo "Is $class instantiable? "; var_dump($reflectionClass->IsInstantiable()); } ?>
以上例程会输出:
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)
参见
- ReflectionClass::isInstance() 检查类的实例
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(); ?>