PHP类中的重要知识点
来源:互联网 发布:微信三级分销拼团源码 编辑:程序博客网 时间:2024/06/15 03:17
1. __construct:
内置构造函数,在对象被创建时自动调用。见如下代码:
<?phpclass ConstructTest { private $arg1; private $arg2; public function __construct($arg1, $arg2) { $this->arg1 = $arg1; $this->arg2 = $arg2; print "__construct is called...\n"; } public function printAttributes() { print '$arg1 = '.$this->arg1.' $arg2 = '.$this->arg2."\n"; }}$testObject = new ConstructTest("arg1","arg2"); $testObject->printAttributes();
运行结果如下:
Stephens-Air:Desktop$ php Test.php __construct is called...$arg1 = arg1 $arg2 = arg2
2. parent:
用于在子类中直接调用父类中的方法,功能等同于Java中的super。
<?phpclass BaseClass { protected $arg1; protected $arg2; function __construct($arg1, $arg2) { $this->arg1 = $arg1; $this->arg2 = $arg2; print "__construct is called...\n"; } function getAttributes() { return '$arg1 = '.$this->arg1.' $arg2 = '.$this->arg2; }}class SubClass extends BaseClass { protected $arg3; function __construct($baseArg1, $baseArg2, $subArg3) { parent::__construct($baseArg1, $baseArg2); $this->arg3 = $subArg3; } function getAttributes() { return parent::getAttributes().' $arg3 = '.$this->arg3; }}$testObject = new SubClass("arg1","arg2","arg3"); print $testObject->getAttributes()."\n";
运行结果如下:
Stephens-Air:Desktop$ php Test.php __construct is called...$arg1 = arg1 $arg2 = arg2 $arg3 = arg3
3. self:
在类内调用该类静态成员和静态方法的前缀修饰,对于非静态成员变量和函数则使用this。
<?phpclass StaticExample { static public $arg1 = "Hello, This is static field.\n"; static public function sayHello() { print self::$arg1; }}print StaticExample::$arg1;StaticExample::sayHello();
运行结果如下:
Stephens-Air:Desktop$ php Test.php Hello, This is static field.Hello, This is static field.
4. static:
这里介绍的static关键字主要用于PHP 5.3以上版本新增的延迟静态绑定功能。请看一下代码和关键性注释。
<?phpabstract class Base { public static function getInstance() { //这里的new static()实例化的是调用该静态方法的当前类。 return new static(); } abstract public function printSelf(); }class SubA extends Base { public function printSelf() { print "This is SubA::printSelf.\n"; }}class SubB extends Base { public function printSelf() { print "This is SubB::printSelf.\n"; }}SubA::getInstance()->printSelf();SubB::getInstance()->printSelf();
运行结果如下:
Stephens-Air:Desktop$ php Test.php This is SubA::printSelf.This is SubB::printSelf.
static关键字不仅仅可以用于实例化。和self和parent一样,static还可以作为静态方法调用的标识符,甚至是从非静态上下文中调用。在该场景下,self仍然表示的是当前方法所在的类。见如下代码:
<?phpabstract class Base { private $ownedGroup; public function __construct() { //这里的static和上面的例子一样,表示当前调用该方法的实际类。 //需要另外说明的是,这里的getGroup方法即便不是静态方法,也会得到相同的结果。然而倘若 //getGroup真的只是普通类方法,那么这里还是建议使用$this。 $this->ownedGroup = static::getGroup(); } public function printGroup() { print "My Group is ".$this->ownedGroup."\n"; } public static function getInstance() { return new static(); } public static function getGroup() { return "default"; }}class SubA extends Base {}class SubB extends Base { public static function getGroup() { return "SubB"; }}SubA::getInstance()->printGroup();SubB::getInstance()->printGroup();
运行结果如下:
Stephens-Air:Desktop$ php Test.php My Group is defaultMy Group is SubB
5. __destruct:
析构方法的作用和构造方法__construct刚好相反,它只是在对象被垃圾收集器收集之前自动调用,我们可以利用该方法做一些必要的清理工作。
<?phpclass TestClass { function __destruct() { print "TestClass destructor is called.\n"; }}$testObj = new TestClass();unset($testObj);print "Application will exit.\n";
运行结果如下:
Stephens-Air:Desktop$ php Test.php TestClass destructor is called.Application will exit.
6. __clone:
在PHP 5之后的版本中,对象之间的赋值为引用赋值,即赋值后的两个对象将指向同一地址空间,如果想基于对象赋值,可以使用PHP提供的clone方法。该方法将当前对象浅拷贝之后的副本返回,如果想在clone的过程中完成一些特殊的操作,如深拷贝,则需要在当前类的声明中实现__clone方法,该方法在执行clone的过程中会被隐式调用。另外需要格外注意的是,__clone方法是作用再被拷贝的对象上,即赋值后的对象上执行。
<?phpclass InnerClass { public $id = 10; public function printSelf() { print '$id = '.$this->id."\n"; }}class OuterClass { public $innerClass; public function __construct() { $this->innerClass = new InnerClass(); } public function __clone() { $this->innerClass = clone $this->innerClass; print "__clone is called.\n"; }}$outerA = new OuterClass();print "Before calling to clone.\n";$outerB = clone $outerA;print "After calling to clone.\n";$outerA->innerClass->id = 20;print "In outerA: ";$outerA->innerClass->printSelf();print "In outerB: ";$outerB->innerClass->printSelf();
运行结果如下:
Stephens-Air:Desktop$ php Test.php Before calling to clone.__clone is called.After calling to clone.In outerA: $id = 20In outerB: $id = 10
7. const:
PHP5可以在类中定义常量属性。和全局常量一样,一旦定义就不能改变。常量属性不需要像普通属性那样以$开头,按照惯例,只能用大写字母来命名常量。另外和静态属性一样,只能通过类而不能通过类的实例访问常量属性,引用常量时同样也不需要以$符号作为前导符。另外常量只能被赋值为基础类型,如整型,而不能指向任何对象类型。
<?phpclass TestClass { const AVAILABLE = 0;}print "TestClass::AVAILABLE = ".TestClass::AVAILABLE."\n";
运行结果如下:
0Stephens-Air:Desktop$ php Test.php TestClass::AVAILABLE = 0
8. __toString:
当对象被打印时,如果该类定义了该方法,则打印该方法的返回值,否则将按照PHP的缺省行为输出打印结果。该方法类似于Java中的toString()。
<?phpclass TestClass { public function __toString() { return "This is TestClass::__toString.\n"; }}$testObj = new TestClass();print $testObj;
运行结果如下:
Stephens-Air:Desktop$ php Test.php This is TestClass::__toString.
9. __get和__set:
这两个方法用于处理类中未声明的属性访问。当对象使用者试图访问未声明的对象属性时,__get()会被调用,并带有一个包含要访问的属性名称字符串作为参数。无论从__get()方法返回什么,都会直接返回给调用者,就如同带有该值的属性存在一样。另外需要注意的是,如果属性存在,但是其访问可见性为private或protected,那么这两个拦截方法同样会被调用,反之,如果属性存在切可访问,那么直接访问属性即可,这两个方法将不再会被调用。以下为__get()拦截方法的示例代码:
<?phpclass TestClass { private $privateField; public $publicField; public function __construct() { $this->privateField = "This is a private Field.\n"; $this->publicField = "This is a public Field.\n"; } public function __get($property) { print "__get() is called.\n"; $method = "get${property}"; if (method_exists($this, $method)) { return $this->$method(); } return "This is undefined field.\n"; } public function getPrivateField() { return $this->privateField; }}$testObj = new TestClass();print $testObj->privateField;print $testObj->undefinedField;print $testObj->publicField;
运行结果如下:
Stephens-Air:Desktop$ php Test.php __get() is called.This is a private Field.__get() is called.This is undefined field.This is a public Field.
__set()方法被调用的规则和__get()基本相同,差别是用于拦截未定义或不可见类属性的赋值操作。另外,该方法接收两个参数,分别是属性名称和要设定的值。见如下代码示例:
<?phpclass TestClass { private $privateField; public $publicField; public function __construct() { $this->privateField = "This is a private Field.\n"; $this->publicField = "This is a public Field.\n"; } public function __get($property) { print "__get() is called.\n"; $method = "get${property}"; if (method_exists($this, $method)) { return $this->$method(); } return "This is an undefined field.\n"; } public function __set($property, $value) { print "__set is called.\n"; $method = "set${property}"; if (method_exists($this, $method)) { $this->$method($value); } else { print "This is an undefined field.\n"; } } public function getPrivateField() { return $this->privateField; } public function setPrivateField($value) { $this->privateField = $value; }}$testObj = new TestClass();$testObj->privateField = "This is a private Field after set.\n";$testObj->undefinedField = "This is a undefined Field after set.\n";$testObj->publicField = "This is a public Field after set.\n";print $testObj->privateField;print $testObj->undefinedField;print $testObj->publicField;
运行结果如下:
Stephens-Air:Desktop$ php Test.php __set is called.__set is called.This is an undefined field.__get() is called.This is a private Field after set.__get() is called.This is an undefined field.This is a public Field after set.
10. __isset和__unset:
这两个拦截方法被调用的规则和__get()和__set()非常类似,只是用于类中不存在或不可见属性被isset()和unset()两个全局方法应用时才会被分别触发。
<?phpclass TestClass { private $privateField; public $publicField; public function __construct() { $this->privateField = "Defined private field"; $this->publicField = "Defined public field"; } public function __isset($property) { print "__isset is called.\n"; return isset($this->$property); } public function __unset($property) { print "__unset is called.\n"; if (isset($this->$property)) { unset($this->$property); } }}$testObj = new TestClass();print 'isset($testObj->privateField) is '.(isset($testObj->privateField) ? "true" : "false")."\n";print 'isset($testObj->undefinedField) is '.(isset($testObj->undefinedField) ? "true" : "false")."\n";print 'isset($testObj->publicField) is '.(isset($testObj->publicField) ? "true" : "false")."\n";print "After unset......\n";//下面两个函数调用后,$testObj的两个对象属性均会变为不可用。//另外从输出结果来看,__unset方法仅仅被调用一次,因为publicField为可见属性,所以__unset不会因该属性而被调用。unset($testObj->privateField);unset($testObj->publicField);print 'isset($testObj->privateField) is '.(isset($testObj->privateField) ? "true" : "false")."\n";print 'isset($testObj->publicField) is '.(isset($testObj->publicField) ? "true" : "false")."\n";
运行结果如下:
Stephens-Air:Desktop$ php Test.php __isset is called.isset($testObj->privateField) is true__isset is called.isset($testObj->undefinedField) is falseisset($testObj->publicField) is trueAfter unset......__unset is called.__isset is called.isset($testObj->privateField) is false__isset is called.isset($testObj->publicField) is false
11. __call:
__call()方法是一个非常有用但又非常容易被滥用的拦截方法。当对象使用者试图访问当前对象未定义的成员函数时,__call()会被自动调用,同时传递两个参数,分别为函数名称和传递给调用函数的所有参数(数组)。__call方法返回的任何值都会返回给函数调用者,就如同该成员函数真实存在一样。下面给出一个非常有用的委托示例。
<?phpclass DelegateClass { function printMessage($arg1, $arg2) { print "DelegateClass:delegatedMethod is called.\n"; print '$arg1 = '.$arg1.'and $arg2 = '.$arg2."\n"; }}class TestClass { private $delegateObj; public function __construct() { $this->delegateObj = new DelegateClass(); } public function __call($method, $args) { $this->delegateObj->$method($args[0],$args[1]); }}$testObj = new TestClass();$testObj->printMessage("hello","world");
运行结果如下:
Stephens-Air:Desktop$ php Test.php DelegateClass:delegatedMethod is called.$arg1 = helloand $arg2 = world
从以上示例可以看出,TestClass并未声明printMessage成员方法,但是通过__call()方法的巧妙桥接直接传递给了委托对象。个人认为该技巧为双刃剑,切勿过度使用。
12. 回调函数:
回调函数的应用场景无须多述,在C/C++中充斥着无数的回调函数典型用例。 这里只是简单给出PHP中回调函数的使用规则。见如下示例代码和关键性注释:
<?phpclass Product { public $name; public $price; public function __construct($name, $price) { $this->name = $name; $this->price = $price; }}class ProcessSale { private $callbacks; function registerCallback($cb) { if (!is_callable($cb)) { throw new Exception("callback not callable."); } $this->callbacks[] = $cb; } function sale($product) { print "{$product->name}: processing \n"; foreach ($this->callbacks as $cb) { //以下两种调用方式均可。 call_user_func($cb, $product); $cb($product); } }}$logger = function($product) { print " logging ({$product->name})\n";};$processor = new ProcessSale();$processor->registerCallback($logger);$processor->sale(new Product("shoes",6));print "\n";$processor->sale(new Product("coffee",6));
运行结果如下:
Stephens-Air:Desktop$ php Test.php shoes: processing logging (shoes) logging (shoes)coffee: processing logging (coffee) logging (coffee)
13. use(闭包):
在Javascript中存在大量的闭包应用,PHP中的闭包则是通过use关键字来完成的。对于闭包这个概念本身而言,简要的说就是函数内的代码可以访问其父作用域中的变量。见如下示例代码和关键性注释:
<?phpclass Product { public $name; public $price; public function __construct($name, $price) { $this->name = $name; $this->price = $price; }}class ProcessSale { private $callbacks; function registerCallback($cb) { if (!is_callable($cb)) { throw new Exception("callback not callable."); } $this->callbacks[] = $cb; } function sale($product) { print "{$product->name}: processing \n"; foreach ($this->callbacks as $cb) { $cb($product); } }}class Totalizer { static function warnAmount($amt) { $count = 0; //注意这里的$amt和$count均为闭包变量,其中&$count是以引用的形式传递的,即一旦函数内部修改了该变量的值, //那么下次再访问该闭包变量时,$count将为之前调用中修改后的值。 return function($product) use($amt, &$count) { $count += $product->price; print " count: $count\n"; if ($count > $amt) { print " high price reached: {$count}\n"; } }; }}$processor = new ProcessSale();$processor->registerCallback(Totalizer::warnAmount(8));$processor->sale(new Product("shoes",6));$processor->sale(new Product("coffee",6));
运行结果如下:
shoes: processing count: 6coffee: processing count: 12 high price reached: 12
14. namespace:
和C++中的名字空间很像,作用也一样,都是为了避免在引用较多第三方库时而带来的名字冲突问题。通过名字空间,即便两个class的名称相同,但是因为位于不同的名字空间内,他们仍然可以被精确定位和区分。第一次看到PHP的名字空间语法时,感觉和C++相比在语法上是非常非常相似的,然而在写点儿小例子做做实验的时候才发现,他们的差别还是很大的,为了避免以后忘记,所以这里特别将其记录了下来。见如下代码:
<?php//in Test2.phpnamespace nstest\test2;class Test2 { public static function printMe() { print 'This is nstest\test2\Test2::printSelf.'."\n"; }}<?php//in Test1.phpnamespace nstest\test1;class Test1 { public static function printMe() { print 'This is nstest\test1\Test1::printSelf.'."\n"; }}require "Test2.php";nstest\test2\Test2::printMe();
运行结果如下:
bogon:TestPhp$ php Test1.php PHP Fatal error: Class 'nstest\test1\nstest\test2\Test2' not found in /Users/liulei/PhpstormProjects/TestPhp/Test1.php on line 13
是不是这个结果比较出乎意料,原因在哪呢?HOHO,原来PHP在进行名字空间引用的时候,如果名字空间的第一个字符不是前导斜杠(\),那么就被自动识别为相对名字空间,在上面的代码中,Test1自身所在的名字空间是namespace nstest\test1,因此在以nstest\test2\Test2::printMe()方式调用Test2::printMe()时,PHP将自动解析为nstest\test1\nstest\test2\Test2::printMe(),即认为nstest\test2是在当前名字空间内部的。修正该问题非常简单,只需在引用时加上前导斜杠(\)即可,见以下修复后的代码:
<?php//Test2.phpnamespace nstest\test2;class Test2 { public static function printMe() { print 'This is nstest\test2\Test2::printSelf.'."\n"; }}<?php//Test1.phpnamespace nstest\test1;class Test1 { public static function printMe() { print 'This is nstest\test1\Test1::printSelf.'."\n"; }}require "Test2.php";\nstest\test2\Test2::printMe();
运行结果如下:
bogon:TestPhp$ php Test1.php This is nstest\test2\Test2::printSelf.
还有一种改动方式,可以示意一下PHP中名字空间中的相对引用。这里我们可以将Test1的名字空间改为namespace nstest,其他的修改见以下代码中红色高亮部分:
<?php//Test2.phpnamespace nstest\test2;class Test2 { public static function printMe() { print 'This is nstest\test2\Test2::printSelf.'."\n"; }}<?php//Test1.phpnamespace nstest;class Test1 { public static function printMe() { print 'This is nstest\test1\Test1::printSelf.'."\n"; }}require "Test2.php";test2\Test2::printMe();
运行结果等于上面正确的结果。最重要的差别就是该例使用了PHP名字空间中的相对定位。相信熟悉C++的开发者一定会想到use关键字,PHP也提供了该关键字,他们的功能是一致的,都是为了避免在后面的代码中,无需再通过全限定符(类名前加名字空间前缀)来引用其他名字空间中的类了。至于具体的语法规则,还是看看下面具体的代码和关键性注释吧。
<?php//Test2.phpnamespace nstest\test2;class Test2 { public static function printMe() { print 'This is nstest\test2\Test2::printSelf.'."\n"; }}<?php//Test1.phpnamespace nstest\test1;class Test1 { public static function printMe() { print 'This is nstest\test1\Test1::printSelf.'."\n"; }}require "Test2.php";//这里需要特别注意的是,nstest\test2已经表示名字空间绝对路径定位,不需要再加前导斜杠(\)了。//另外这里还有一个隐式规则是test2表示该名字空间的缺省别名,在引用其名字空间内的对象时需要加test2前缀。use nstest\test2;test2\Test2::printMe();//这里我们也可以给名字空间显式的指定别名,如:use nstest\test2 as test2_alias;test2_alias\Test2::printMe();
运行结果如下:
bogon:TestPhp$ php Test1.php This is nstest\test2\Test2::printSelf.This is nstest\test2\Test2::printSelf.
最后介绍一下PHP中全局名字空间的引用方式,见如下代码和关键性注释:
<?phpclass Test { public static function printMe() { print 'This is Global namespace Test::printSelf.'."\n"; }}//下面两行代码表示的是同一对象,即全局名字空间下的Test类,然而如果因为名字空间冲突导致第一种方式不能被PHP//编译器正常识别,那么就可以使用第二种方式显式的通知PHP,自己要引用的是全局名字空间中的Test类。Test::printMe();\Test::printMe();
运行结果如下:
bogon:TestPhp$ php Test1.php This is Global namespace Test::printSelf.This is Global namespace Test::printSelf.
15. Reflection:
PHP中的反射和Java中java.lang.reflect包提供的功能一样,更有意思的是,就连很多方法命名和调用方式也是非常雷同的。他们都是由一些列可以分析类、类方法和方法参数的PHP内置类组成。我们这里主要介绍的是如下几个常用的内置类:(Reflection、RelectionClass、ReflectionMethod、ReflectionParameter和ReflectionProperty)。现在我们还是一步一步来理解,即从ReflectionClass开始给出示例代码和关键性注释:
<?phpclass TestClass { public $publicVariable; function publicMethod() { print "This is publicMethod.\n"; }}function classInfo(ReflectionClass $c) { $details = ""; //getName将返回实际的类名。 $name = $c->getName(); if ($c->isUserDefined()) { $details .= "$name is user defined.\n"; } if ($c->isInternal()) { $details .= "$name is built-in.\n"; } if ($c->isAbstract()) { $details .= "$name is abstract class.\n"; } if ($c->isFinal()) { $details .= "$name is final class.\n"; } if ($c->isInstantiable()) { $details .= "$name can be instantiated.\n"; } else { $details .= "$name cannot be instantiated.\n"; } return $details;}function classSource(ReflectionClass $c) { $path = $c->getFileName(); $lines = @file($path); //获取类定义代码的起始行和截至行。 $from = $c->getStartLine(); $to = $c->getEndLine(); $len = $to - $from + 1; return implode(array_slice($lines,$from - 1,$len));}print "The following is Class Information.\n";print classInfo(new ReflectionClass('TestClass'));print "\nThe following is Class Source.\n";print classSource(new ReflectionClass('TestClass'));
运行结果如下:
bogon:TestPhp$ php reflection_test.php The following is Class Information.TestClass is user defined.TestClass can be instantiated.The following is Class Source.class TestClass { public $publicVariable; function publicMethod() { print "This is publicMethod.\n"; }}
下面让我们仍然以代码示例和关键性注释的方法继续ReflectionMethod的学习之旅。
<?phpclass TestClass { public $publicVariable; function __construct() { } private function privateMethod() { } function publicMethod() { print "This is publicMethod.\n"; } function publicMethod2(string $arg1, int $arg2) { }}//这个函数中使用的ReflectionMethod中的方法都是非常简单直观的,就不再过多赘述了。function methodInfo(ReflectionMethod $m) { $name = $m->getName(); $details = ""; if ($m->isUserDefined()) { $details .= "$name is user defined.\n"; } if ($m->isInternal()) { $details .= "$name is built-in.\n"; } if ($m->isAbstract()) { $details .= "$name is abstract.\n"; } if ($m->isPublic()) { $details .= "$name is public.\n"; } if ($m->isProtected()) { $details .= "$name is protected.\n"; } if ($m->isPrivate()) { $details .= "$name is private.\n"; } if ($m->isStatic()) { $details .= "$name is static.\n"; } if ($m->isFinal()) { $details .= "$name is final.\n"; } if ($m->isConstructor()) { $details .= "$name is constructor.\n"; } if ($m->returnsReference()) { $details .= "$name returns a reference.\n"; } return $details;}function methodSource(ReflectionMethod $m) { $path = $m->getFileName(); $lines = @file($path); $from = $m->getStartLine(); $to = $m->getEndLine(); $len = $to - $from + 1; return implode(array_slice($lines, $from - 1, $len));}$rc = new ReflectionClass('TestClass');$methods = $rc->getMethods();print "The following is method information.\n";foreach ($methods as $method) { print methodInfo($method); print "\n--------------------\n";}print "The following is Method[TestClass::publicMethod] source.\n";print methodSource($rc->getMethod('publicMethod'));
运行结果如下:
bogon:TestPhp$ php reflection_test.php The following is method information.__construct is user defined.__construct is public.__construct is constructor.--------------------privateMethod is user defined.privateMethod is private.--------------------publicMethod is user defined.publicMethod is public.--------------------publicMethod2 is user defined.publicMethod2 is public.--------------------The following is Method[TestClass::publicMethod] source. function publicMethod() { print "This is publicMethod.\n"; }
让我们继续ReflectionParameter吧,他表示的是成员函数的参数信息。继续看代码吧。
<?phpclass ParamClass {}class TestClass { function publicMethod() { print "This is publicMethod.\n"; } function publicMethod2(ParamClass $arg1, &$arg2, $arg3 = null) { }}function paramInfo(ReflectionParameter $p) { $details = ""; //这里的$declaringClass将等于TestClass。 $declaringClass = $p->getDeclaringClass(); $name = $p->getName(); $class = $p->getClass(); $position = $p->getPosition(); $details .= "\$$name has position $position.\n"; if (!empty($class)) { $classname = $class->getName(); $details .= "\$$name must be a $classname object\n"; } if ($p->isPassedByReference()) { $details .= "\$$name is passed by reference.\n"; } if ($p->isDefaultValueAvailable()) { $def = $p->getDefaultValue(); $details .= "\$$name has default: $def\n"; } return $details;}$rc = new ReflectionClass('TestClass');$method = $rc->getMethod('publicMethod2');$params = $method->getParameters();foreach ($params as $p) { print paramInfo($p)."\n";}
运行结果如下:
bogon:TestPhp$ php reflection_test.php $arg1 has position 0.$arg1 must be a ParamClass object$arg2 has position 1.$arg2 is passed by reference.$arg3 has position 2.$arg3 has default:
上面介绍的都是通过PHP提供的Reflection API来遍历任意class的具体信息,事实上和Java等其他语言提供的反射功能一样,PHP也同样支持通过反射类调用实际对象的方法,这里将主要应用到两个方法,分别是ReflectionClass::newInstance()来创建对象实例,另一个是ReflectionMethod::invoke(),根据对象实例和方法名执行该方法。见如下代码:
<?phpclass TestClass { private $privateArg; function __construct($arg) { $this->privateArg = $arg; } function publicMethod() { print '$privateArg = '.$this->privateArg."\n"; } function publicMethod2($arg1, $arg2) { print '$arg1 = '.$arg1.' $arg2 = '.$arg2."\n"; }}$rc = new ReflectionClass('TestClass');$testObj = $rc->newInstanceArgs(array('This is private argument.'));$method = $rc->getMethod('publicMethod');$method->invoke($testObj);$method2 = $rc->getMethod('publicMethod2');$method2->invoke($testObj,"hello","world");
运行结果如下:
bogon:TestPhp$ php reflection_test.php $privateArg = This is private argument.$arg1 = hello $arg2 = world
事实上ReflectionClass、ReflectionMethod和ReflectionParameter提供给我们的可用方法还有更多,这里只是给出几个最典型的方法,以便我们可以更为直观的学习和了解PHP Reflection API。相信再看完以后的代码示例之后,我们都会比较清楚,如果今后需要用到和class相关的功能,就从ReflectionClass中查找,而member function的信息则一定来自于ReflectionMethod,方法参数信息来自于ReflectionParameter。
转自 http://www.cnblogs.com/stephen-liu74/
- PHP类中的重要知识点
- Unity3d中的重要知识点
- C++中的零散重要知识点
- C++中的几个重要知识点
- Flex中的RPC服务重要知识点
- 重要知识点
- 重要知识点
- 重要知识点
- android中的重要java知识点回顾1(枚举、反射、类加载器等)
- PHP 从基础开始 ——重要知识点笔记
- php中oop中的三个重要特性
- android中的重要java知识点回顾2(内省、注解、泛型、代理类、动态类、AOP框架等等)
- php中的访问修饰符知识点
- 重要知识点总结
- C++重要知识点
- C++重要知识点
- C++重要知识点
- asp.net 重要知识点
- JSP和Servlet
- Leetcode题解(Python): 2.Add Two Numbers
- java 使用IO从网络下载图片-
- memcached
- CoreText 实现图文混排
- PHP类中的重要知识点
- tomcat启动正常,但是项目无法访问
- 验证二叉查找树
- jQuery深入之源码解析(三)——构造jQuery对象
- 【Android】Android之命令行安装apk
- 田忌赛马
- 将xml布局转换成View的几种方式
- [分享] Wex5 作品 仿微信聊天工具 部分代码 详情 留下邮箱
- greenplum数据库引擎探究