55);

    /**
     * 构造方法 
     * 当类被实力化时就会被出发此方法
     * 该方法就不用演示了
     */
    function __construct()
    {
        echo '构造方法：__construct()
';
    }
    
    
    /**
     * 对象被序列化时会先出发此方法 
     * 如果没有此魔术方法 会把 类属性 $a,$b,$c 序列化
     * 此方法可以指定那些属性被序列化
     */
    public function __sleep() 
    {
        return array( 'a' ,  'b' );
    }
    
    
    /**
     * 对象被反序列化时会先出发此方法
     */
    public function __wakeup() 
    {
        echo 1;
    }
    
    /**
     * 方法用于一个类被当成字符串时应怎样回应。例如 echo $obj; 应该显示些什么。
     * 此方法必须返回一个字符串，否则将发出一条 E_RECOVERABLE_ERROR  级别的致命错误
     */
    public function __toString()
    {
        return 'echo 对象？
';
    }
    
    
    /**
     * 自 PHP 5.1.0 起当调用 var_export()  导出类时，此静态 方法会被调用。 
     * 本方法的唯一参数是一个数组，其中包含按 array('property' => value, ...) 格式排列的类属性。
     */
    public static function __set_state($array) 
    {
        return $array['d'];
    }
    
    
    /**
     * PHP 5 引入了析构函数的概念，这类似于其它面向对象的语言，
     * 如 C++。析构函数会在到某个对象的所有引用都被删除或者当对象被显式销毁时执行。 
     * 
     * 该方法就不用演示了
     */
    public function __destruct()
    {
        //echo 55;
    }
    
    
    /**
     * 在对象中调用一个不可访问方法时，__call() 会被调用
     */
    public function __call($name, $arguments) {
        echo '__call() ： ';
        // 注意: $name 的值区分大小写
        var_dump($name);
        var_dump($arguments);
        echo '
';
        if( $name == 'abc' )
        {
            $this->$name();
        }
    }
    private function abc()
    {
        echo '999
';
    }
    
    
    /**
     * 用静态方式中调用一个不可访问方法时，__callStatic() 会被调用。 
     */
    public static function  __callStatic ( $name ,  $arguments ) 
    {
        echo '__callStatic() ： ';
        // 注意: $name 的值区分大小写
        var_dump($name);
        var_dump($arguments);
        echo '
';
    }

    
    /**
     * 在给不可访问属性赋值时，__set() 会被调用。 
     */
    public function __set( $name,$val )
    {
        echo '__set ： 方法
';
        $this->$name = $val;
    }
    
    
    /**
     * 读取不可访问属性的值时，__get() 会被调用。  
     */
    public function __get( $name )
    {
        echo '__get ： 方法
';
        return $this->$name;
    }
    
    
    /**
     * 判断属性是否存在时被调用
     */
    public function __isset($name) 
    {
        echo '__isset ： 方法
';
        return isset( $this->e[$name] );
    }
    
    
    /**
     * 当对不可访问属性调用 unset()  时，__unset() 会被调用。 
     */
    public function __unset($name)
    {
        echo '__unset ： 方法
';
        unset( $this->$name );
        var_dump($name);
    }
    
    
    /**
     * 对象被克隆时被调用的
     */
    public function __clone()
    {
        echo '__clone ： 方法';
        echo '： 被克隆了
';
    }
    
    
    /**
     * 当尝试以调用函数的方式调用一个对象时，__invoke() 方法会被自动调用。 
     */
    public function  __invoke ( $x ) 
    {
        echo '__invoke ： 方法 
';
         var_dump ( $x );
    }

}

$ob = new magic();


/**
 * __sleep() 事例
 * var_dump(serialize($ob));
 */


/**
 * __wakeup 事例
 * $ser = serialize($ob);
 * unserialize($ser);
 */


/**
 * __toString 事例
 * echo $ob;
 */


/**
 * __set_state 事例 手册里
 * eval('$b = '.var_export($ob,true).';');
 * var_dump($b);
 */


/**
 * __call 事例
 * $ob->meiyou();
 * $ob->abc(1,2);
 */



/**
 * __callStatic 事例 
 * magic::kao(22);
 */


/**
 * __set 事例
 * print_r($ob);
 * $ob->c=2;
 * print_r($ob);
 */



/**
 * __get 事例
 * print_r($ob->c);
 */



/**
 * __isset 事例
 * var_dump( isset($ob->huazi) );
 */


/**
 * __unset 事例
 * unset($ob->b);
 * print_r($ob);
 */



/**
 * __clone 事例
 * $c = clone $ob;
 */



/**
 * __invoke 事例
 * $ob('hehe');
 */


class a{
    function __construct(){
        
    }
    function __destruct(){
        
    }
    function __call( $name,$val ){
        
    }
    static function __callStatic($name, $arguments) {
    }
    function __get($name){
        
    }
    function __set($name,$val){
        
    }
    function __unset($name){
        
    }
    function __isset($name){
        
    }
    function __toString() {
    }
    function __set_state($array) {
    }
    function __invoke(){
        
    }
    function __clone(){
        
    }
    function __sleep(){
    }
    function __wakeup(){
    }    
}