PHP类中的重要知识点

1. __construct: 

     内置构造函数，在对象被创建时自动调用。见如下代码：

php
class 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。 

php
class 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。 

php
class 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以上版本新增的延迟静态绑定功能。请看一下代码和关键性注释。

php
abstract 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仍然表示的是当前方法所在的类。见如下代码： 

php
abstract 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 default
My Group is SubB

5. __destruct:

     析构方法的作用和构造方法__construct刚好相反，它只是在对象被垃圾收集器收集之前自动调用，我们可以利用该方法做一些必要的清理工作。

php
class 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方法是作用再被拷贝的对象上，即赋值后的对象上执行。

php
class 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 = 20
In outerB: $id = 10

7. const:

    PHP5可以在类中定义常量属性。和全局常量一样，一旦定义就不能改变。常量属性不需要像普通属性那样以$开头，按照惯例，只能用大写字母来命名常量。另外和静态属性一样，只能通过类而不能通过类的实例访问常量属性，引用常量时同样也不需要以$符号作为前导符。另外常量只能被赋值为基础类型，如整型，而不能指向任何对象类型。

php
class TestClass {
    const AVAILABLE = 0;
}

print "TestClass::AVAILABLE = ".TestClass::AVAILABLE."\n";

    运行结果如下：

0Stephens-Air:Desktop$ php Test.php 
TestClass::AVAILABLE = 0

8. __toString:

    当对象被打印时，如果该类定义了该方法，则打印该方法的返回值，否则将按照PHP的缺省行为输出打印结果。该方法类似于Java中的toString()。

php
class 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()拦截方法的示例代码：

php
class 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()基本相同，差别是用于拦截未定义或不可见类属性的赋值操作。另外，该方法接收两个参数，分别是属性名称和要设定的值。见如下代码示例：

php
class 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()两个全局方法应用时才会被分别触发。 

php
class 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 false
isset($testObj->publicField) is true
After 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方法返回的任何值都会返回给函数调用者，就如同该成员函数真实存在一样。下面给出一个非常有用的委托示例。 

php
class 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中回调函数的使用规则。见如下示例代码和关键性注释： 

php
class 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关键字来完成的。对于闭包这个概念本身而言，简要的说就是函数内的代码可以访问其父作用域中的变量。见如下示例代码和关键性注释：

php
class 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: 6
coffee: processing 
     count: 12
     high price reached: 12

14. namespace:

    和C++中的名字空间很像，作用也一样，都是为了避免在引用较多第三方库时而带来的名字冲突问题。通过名字空间，即便两个class的名称相同，但是因为位于不同的名字空间内，他们仍然可以被精确定位和区分。第一次看到PHP的名字空间语法时，感觉和C++相比在语法上是非常非常相似的，然而在写点儿小例子做做实验的时候才发现，他们的差别还是很大的，为了避免以后忘记，所以这里特别将其记录了下来。见如下代码：

php
//in Test2.php
namespace nstest\test2;

class Test2 {
    public static function printMe() {
        print 'This is nstest\test2\Test2::printSelf.'."\n";
    }
}

php
//in Test1.php
namespace 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.php
namespace nstest\test2;

class Test2 {
    public static function printMe() {
        print 'This is nstest\test2\Test2::printSelf.'."\n";
    }
}

php
//Test1.php
namespace 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.php
namespace nstest\test2;

class Test2 {
    public static function printMe() {
        print 'This is nstest\test2\Test2::printSelf.'."\n";
    }
}

php
//Test1.php
namespace 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.php
namespace nstest\test2;

class Test2 {
    public static function printMe() {
        print 'This is nstest\test2\Test2::printSelf.'."\n";
    }
}

php
//Test1.php
namespace 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中全局名字空间的引用方式，见如下代码和关键性注释：

php
class 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开始给出示例代码和关键性注释： 

php
class 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的学习之旅。

php
class 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吧，他表示的是成员函数的参数信息。继续看代码吧。

php
class 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()，根据对象实例和方法名执行该方法。见如下代码：

php
class 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/