类成员重载-全局成员-命名空间声明访问分解合并-子空间访问任何空间成员

类成员重载-全局成员-命名空间声明访问分解合并-子空间访问任何空间成员

1. 描述类成员重载的原理与实现，并实例演示;
2. 全局成员有哪几种，有什么特点，并实例演示;
3. 实例演示空间的声明与空间成员的访问;
4. 实例演示空间成员的分解与合并操作;
5. 实例演示子空间，并在子空间中访问任何空间中的成员的方式;

1. 描述类成员重载的原理与实现，并实例演示

• 访问或设置类中不存在的属性或方法时，调用的魔术方法

class Demo
{
    // 私有属性
    private $data = [];
    // 公开方法
    public function data()
    {
        return $this->data;
    }
    // 设置类中不存在的属性时调用
    public function __set($name, $value)
    {
        $this->data[$name] = $value;
    }
    // 访问类中不存在的属性时调用
    public function __get($name)
    {
        if (isset($this->data[$name]))
            return $this->data[$name];
        return 'Property ' . $name . ' not exist.';
    }
    // 访问类中不存在的方法时调用
    public function __call($name, $arguments)
    {
        if (method_exists($this, $name))
            return call_user_func_array([$this, $name], $arguments);
        return 'Method ' . $name . ' not exist.';
    }
    // 访问类中不存在的静态方法时调用
    public static function __callStatic($name, $arguments)
    {
        return 'Static Method: ' . $name . ', args: ' . implode(',', $arguments);
    }
    // 对象当字符串使用时调用
    public function __toString()
    {
        return 'Magic Method: ' . __FUNCTION__;
    }
    // 对象当函数使用时调用
    public function __invoke()
    {
        return 'Magic Method: ' . __FUNCTION__;
    }
    // 对象序列化时调用
    public function __sleep()
    {
        return ['Magic Method',  __FUNCTION__];
    }
    // 对象反序列化时调用
    public function __wakeup()
    {
        echo 'Magic Method: ' . __FUNCTION__;
    }
}
$obj = new Demo();
// 设置类中不存在的属性
$obj->hello = 'hello world!';
// hello world!
echo $obj->hello, '<br>';
// 访问类中不存在的属性
// Property world not exist.
echo $obj->world, '<br>';
// 访问类中存在的方法
// Array ( [hello] => hello world! )
echo print_r($obj->data(), true), '<br>';
// 访问类中不存在的方法
// Method func not exist.
echo $obj->func(), '<br>';
// 访问类中不存在的静态方法
// Static Method: func, args: hello,world!
echo Demo::func('hello', 'world!'), '<br>';
// 对象当字符串使用时
// Magic Method: __toString
echo $obj, '<br>';
// 对象当函数使用时
// Magic Method: __invoke
echo $obj(), '<br>';
// 对象序列化时
$serObj = serialize($obj);
// O:4:"Demo":2:{s:12:"Magic Method";N;s:7:"__sleep";N;}
echo $serObj, '<br>';
// 对象反序列化时
// Magic Method: __wakeup
unserialize($serObj);
echo '<hr>';

2. 全局成员有哪几种，有什么特点，并实例演示

• 全局成员：类，常量，函数
• 特点：不能重复声明

// 类
class App
{
    public $app = __CLASS__;
}
// 常量
const APP = 'Helo App';
// 函数
function app()
{
    return __FUNCTION__;
}
// 类
// App
echo (new App)->app, '<br>';
// 常量
// Helo App
echo APP, '<br>';
// 函数
// app
echo app(), '<br>';

3. 实例演示空间的声明与空间成员的访问

• 新建一个 0222-2.php 文件

// 全局空间
namespace {
    // 类
    class App
    {
        public $app = 'App';
    }
    // 常量
    const APP = 'Helo App';
    // 函数
    function app()
    {
        return 'app';
    }
    // 类
    // App
    echo App::class, '<br>';
    // 常量
    // APP
    echo APP::class, '<br>';
    // 函数
    // app
    echo app::class, '<hr>';
}
// 命名空间
namespace Ns {
    // 类
    class App
    {
        public $app = 'App';
    }
    // 常量
    const APP = 'Helo App';
    // 函数
    function app()
    {
        return 'app';
    }
    // 类
    // Ns\App
    echo App::class, '<br>';
    // 常量
    // Ns\APP
    echo APP::class, '<br>';
    // 函数
    // Ns\app
    echo app::class, '<hr>';
}

4. 实例演示空间成员的分解与合并操作

• 将上面命名空间 Ns 分解到 0222-3.php 合并 0222-3-1.php, 0222-3-2.php, 0222-3-3.php

• 新建 0222-3.php

// 命名空间
namespace Ns;
require '0222-3-1.php';
require '0222-3-2.php';
require '0222-3-3.php';
// 类
// Ns\App
echo App::class, '<br>';
// 常量
// Ns\APP
echo APP::class, '<br>';
// 函数
// Ns\app
echo app::class, '<hr>';

• 新建 0222-3-1.php

// 命名空间
namespace Ns {
    // 类
    class App
    {
        public $app = 'App';
    }
}

• 新建 0222-3-2.php

// 命名空间
namespace Ns {
    // 常量
    const APP = 'Helo App';
}

• 新建 0222-3-3.php

// 命名空间
namespace Ns {
    // 函数
    function app()
    {
        return 'app';
    }
}

• 运行合并文件 0222-3.php 图

5. 实例演示子空间，并在子空间中访问任何空间中的成员的方式

• 子空间访问其它空间使用绝对路径

• 新建 0222-4.php

// 全局空间
namespace {
    const HELLO = 'hello world!';
}
// 命名空间
namespace Ns {
    // 类
    class App
    {
        public $app = 'App';
    }
    // 全局空间
    // hello world!
    echo \HELLO, '<hr>';
}
// 子空间
namespace Ns\Ns1 {
    // 常量
    const APP = 'Helo App';
    // 当前空间 - 常量
    // Ns\Ns1\APP
    echo APP::class, '<br>';
    // 父空间 - 类
    // Ns\App
    echo \Ns\App::class, '<br>';
    // 全局空间
    // hello world!
    echo \HELLO, '<hr>';
}
// 子子空间
namespace Ns\Ns1\Ns2 {
    // 函数
    function app()
    {
        return 'app';
    }
    // 父空间 - 类
    // Ns\App
    echo \Ns\App::class, '<br>';
    // 子空间 - 常量
    // Ns\Ns1\APP
    echo \Ns\Ns1\APP::class, '<br>';
    // 当前空间 - 函数
    // Ns\Ns1\Ns2\app
    echo app::class, '<br>';
    // 全局空间
    // hello world!
    echo \HELLO, '<hr>';
}