namespace Name\TraitTest{
    trait AddAndSub{
        function add($a,$b){
            return $a+$b;
        }

        function sub($a,$b){
            return $a-$b;
        }

        function hello()
        {
            echo "trait hello()",PHP_EOL;
        }
    }

    class Base{
        function hello(){
            echo "Base hello()",PHP_EOL;
        }
    }

    class Test extends Base{
        use AddAndSub;
    }

    class Smile extends Base{
        use AddAndSub;
        function hello(){
            echo "Smile hello()",PHP_EOL;
        }
    }


    // PHP Fatal error:  Cannot instantiate trait Name\TraitTest\AddAndSub
    //$a = new AddAndSub();

    $test = new Test();
    echo  $test->add(1,2),PHP_EOL;
    echo  $test->sub(10,1),PHP_EOL;

    $smile = new Smile();
    echo $smile->add(999,123),PHP_EOL;
    echo $smile->sub(1000,23),PHP_EOL;

    /* 从基类继承的成员被 trait 插入的成员所覆盖。优先顺序是来自当前类的成员覆盖了 trait 的
方法，而 trait 则覆盖了被继承的方法 */
    echo  $test->hello(),PHP_EOL; 
    echo $smile->hello(),PHP_EOL;


    //  多个 trait,通过逗号分隔，在 use 声明列出多个 trait，可以都插入到一个类中

    trait Hello{
        public function hello(){
            echo "Hello",PHP_EOL;
        }
    }

    trait World{
        public function world(){
            echo "World",PHP_EOL;
        }
    }

    class HelloWorld{
        use Hello,World;
    }

    $helloWorld = new HelloWorld();
    $helloWorld->hello();
    $helloWorld->world();

    /* 如果两个 trait 都插入了一个同名的方法，如果没有明确解决冲突将会产生一个致命错误。
    为了解决多个 trait 在同一个类中的命名冲突，需要使用 insteadof 操作符来明确指定使用
     冲突方法中的哪一个。
    以上方式仅允许排除掉其它方法，as 操作符可以将其中一个冲突的方法以另一个名称来引入*/
    trait A{
        public function sayHello(){
            echo "A",PHP_EOL;
        }
    }

    trait B{
        public function sayHello(){
            echo "B",PHP_EOL;
        }
    }

    class TestInsteadof{
        use A,B{
            B::sayHello insteadof A;
        }
    }

    $ti = new TestInsteadof();
    $ti->sayHello();

    class TestAlians{
        use A,B{
            A::sayHello insteadof B;
            B::sayHello as hello;
        }
    }

    $ta = new TestAlians();
    $ta->sayHello();
    $ta->hello();

    //使用 as 语法还可以用来调整方法的访问控制

    trait T1{
        public function sayHello(){
            echo "Hello,world!";
        }
    }

    class Test1{
        use T1{ sayHello as protected;}
    }

    class Test2{
        use T1{ sayHello as private myPrivateHello;}
    }

    $test1 = new Test1();
    //$test1->sayHello(); // 错误

    $test2 = new Test2();
    $test2->sayHello();
    //$test2->myPrivateHello(); // 错误

    /* 从 trait 来组成 trait,在 trait 定义时通过使用一个或多个 trait，它能够组合其它 trait 中的
部分 或全部成员 */

    trait TraitHelloWorld{
        use Hello,World;
    }

    class Test3{
        use TraitHelloWorld;
    }

    $test3 = new Test3();
    $test3->hello();
    $test3->world();


    // Trait 的抽象成员,为了对使用的类施加强制要求，trait 支持抽象方法的使用

    trait TestAB{
        public function hello(){
            echo "hello",PHP_EOL;
        }

        abstract public function test();
    }

    class MyTestAB{
        use TestAB;

        public function test(){
            echo "just test",PHP_EOL;
        }
    }

    $myTestab = new MyTestAB();
    $myTestab->hello();
    $myTestab->test();

    //Trait 的静态成员,Trait中可以定义静态方法，方法中还能定义静态变量

    trait Counter{
        public function inc(){
            static $count = 0;
            $count++;
            echo $count,PHP_EOL;
        }

        public static function m(){
            echo "just test in m method",PHP_EOL;
        }
    }

    class C1{
        use Counter;
    }

    class C2{
        use Counter;
    }

    $c = new C1();
    $c->inc();
    C1::m();
    $c2 = new C2();
    $c2->inc();

    /*Trait中同样可以定义属性,如果 trait 定义了一个属性，那类将不能定义同样名称的属性，
     否则会产生一个错误。如果该属性在类中的定义与在 trait 中的定义兼容（同样的可见性和
     初始值） 则错误的级别是 E_STRICT，否则是一个致命错误 */

    trait PropertyTrait{
        public $data = 10;
        public static $m = 123;
    }

    class C3{
        use PropertyTrait;
    }

    $c3 = new C3();
    echo $c3->data,PHP_EOL;
    echo C3::$m,PHP_EOL;
}

$arr = ['name'=>'smilefish','data'=>['a','b','c']];

$json = json_encode($arr);

echo $json,PHP_EOL;

// json_decode 默认会返回一个对象
$object = json_decode($json);
print_r($object);

// json_decode 将第二个参数设置成true,返回一个数组
$arr = json_decode($json,1);
print_r($arr);

function __autoload($className){
    echo "__autoload class:",$className,PHP_EOL;
    require_once("lib/".$className.".php");
}

new Test();

spl_autoload_extensions('.class.php');

//echo get_include_path().PATH_SEPARATOR."lib/";
set_include_path(get_include_path().PATH_SEPARATOR."lib/");

spl_autoload_register();

$test = new Test();


function classLoader($className){
    echo "__autoload class:",$className,PHP_EOL;
    require_once("lib/".$className.".php");
}

spl_autoload_register('classLoader');
new Test();


function classLoader($className){
    echo "__autoload class:",$className,PHP_EOL;
    //require_once("lib/".$className.".php");
    set_include_path("lib/");
    spl_autoload($className);
}

spl_autoload_register('classLoader');
new Test();

// 连接到服务器，选择数据库
$conn = mysql_connect("localhost", "user", "password");
mysql_select_db("database");

// 执行 SQL 查询
$type = $_POST['type'];
$sql = "SELECT * FROM `table` WHERE `type` = {$type}";
$result = mysql_query($sql);

// 打印结果
while($row = mysql_fetch_array($result, MYSQL_ASSOC))
{
      foreach($row as $k => $v)
      print "{$k}: {$v}\n";
}

// 释放结果集，关闭连接
mysql_free_result($result);
mysql_close($conn);

// 连接到数据库
$conn = new PDO("mysql:host=localhost;dbname=database", "user", "password");

// 预编译SQL, 绑定参数
$query = $conn->prepare("SELECT * FROM `table` WHERE `type` = :type");
$query->bindParam("type", $_POST['type']);

// 执行查询并打印结果
foreach($query->execute() as $row)
{
     foreach($row as $k => $v)
     print "{$k}: {$v}\n";
}

// 限制第一个参数为 MyClass, 第二个参数为可执行类型，第三个参数为数组
function func(MyClass $a, callable $b, array $c)
{
// ...
}

class MagicMethod{
    private $data  = array();

    //当对不可访问属性调用unset()函数时，该函数会被调用
    public function __unset($name){
        echo "Unsetting ",$name,PHP_EOL;
        unset($this->data[$name]);
    }

    //当对不可访问属性调用isset()和empty()时，该函数会被调用
    public function __isset($name){
        echo "Is ",$name, " set ?",PHP_EOL;
        return isset($this->data[$name]);
    }

    //构造函数，创建对象前会调用，用于对象的初始化
    public function __construct(){
        echo "__construct",PHP_EOL;
    }

    //析构函数，对对象进行回收时前会调用该函数，用于资源的回收
    public function __destruct(){
        echo "__destruct",PHP_EOL;
    }


    //在给不可访问属性赋值时，该函数会被调用
    public function __set($name,$value){

        echo "Setting ",$name," to the value:",$value,PHP_EOL;
        $this->data[$name]  = $value;
    }

    /* 当serialize()函数被调用时，该方法会在序列化前被调用。可以用于清理对象，
    并返回一个包含对象中所有应该被序列化的变量名称的数组。如果该方法未返回任何内容，
    则NULL被序列化，并产生一个E_NOTICE级别的错误。该函数不能返回父类的私有成员的名称。
    这样会产生一个E_NOTICE级别的错误，可以使用Serializeable接口来替代 */ 
    public function __sleep(){
        echo "__sleep()",PHP_EOL;
        return $this->data;
    }

    //读取不可访问属性的值时，该方法会被调用
    public function __get($name){
        echo "Getting ",$name," value",PHP_EOL;
        if(array_key_exists($name,$this->data)){
            return $this->data[$name];
        }

        return null;
    }

    //当类定义了__call方法()，在对象中调用一个不可访问的方法时，该方法会被调用
    public function __call($name,$arguments){
        echo "calling method :",$name,PHP_EOL;
        echo "the arguments are:",print_r($arguments,true),PHP_EOL;
    }

    /* 当类定义了，静态的方法__callStatic(),以静态方式调用一个不可访问的方法时，
     该方法会被调用 */   
    public static function __callStatic($name,$arguments){

        echo "calling method :",$name,PHP_EOL;
        echo "the arguments are:",print_r($arguments,true),PHP_EOL;
    }

    /* unserialize()函数，会在反序列化之前，先调用该函数预先准备对象需要的资源。
      __wakeup()经常用在反序列化操作中，用于重新建立数据库连接，或者执行其他初始化操作 */
    public function __wakeup(){
        echo "__wakeup()",PHP_EOL;
    }

    /* 当类的对象被当作一个字符串使用时，该方法会被调用，此方法必须返回一个字符串，
     否则将发出一条E_RECOVERABLE_ERROR级别的致命错误，也不能在此方法中抛出异常，
     这么做会导致致命的错误 */
    public function __toString()
    {
        return "Hello,world!";
    }

    // 当尝试一调用函数的方式调用一个对象时，__invoke()方法会被自动调用
    public function __invoke($args){
        echo "__invoke()",PHP_EOL;
        var_dump($args);
    }

    /* 当调用var_export()导出类时，此静态方法会被调用，本方法的唯一参数是一个数组，
     其中包含按array('property'=>value,...)格式排列的类属性; */
    public static function __set_state($args){
        echo "__set_state()",PHP_EOL;
        $obj = new MagicMethod();
        $obj->data = $args;
        return $obj;
    }
    /* 当使用var_dump()函数输出对象的信息时，如果实现了该函数会使用该函数的返回值，
     如果没有实现该函数会输出对象所有的public,protected,private的成员属性 */
    public function __debugInfo(){
        return [
            'title'=> 'magicMethod',
            'data'=> print_r($this->data,true)
        ];
    }

    /* 对象复制可以通过clone关键字完成(如果可能，这将调用对象的__clone()方法)，
      对象中的__clone()方法不能被直接调用。当对象被复制后PHP5会对对象的所有属性执行一个
     浅拷贝，所有的引用属性仍然会是一个指向原来变量的引用。当复制完成时，如果定义了__clone()
     方法，则新创建的对象(复制生成的对象)中的__clone()方法会被调用，可用于修改属性的
     值(如果有必要的话) */
    public function __clone(){
        echo "__clone()",PHP_EOL;
    }
}

// 测试代码

$magic = new MagicMethod();

$magic->hello(123);
MagicMethod::hello(123123123123123123123123123123123123);
echo "hello,world!",PHP_EOL;

echo $magic->b,PHP_EOL;
echo isset($magic->c),PHP_EOL;
echo empty($magic->d),PHP_EOL;
unset($magic->d);
$semagic = serialize($magic);
print_r(unserialize($semagic));
$magic->a = 123;

echo $magic,PHP_EOL;

$magic(6);

echo var_export($magic,true);

var_dump($magic);

$magic2 = clone $magic;

namespace Name\Generators{

    function xrange($start,$limit,$step=1){
        for($i=$start;$i<=$limit;$i+=$step){
            yield $i;
        }
    }

    /* 保存在内存中的数组绝不会被创建或返回,也就是生成器只生成和返回现在需要使用的数据，
     大于大数组可以节省内存空间,不需要一次加载大量数据，只用很少的一部分*/

    foreach(xrange(1,9,2) as $odd){
        echo $odd,PHP_EOL;
    }
}


namespace Name\ForeachList{

    $arr = [
       [1,2],
       ['a','b']
    ];

    foreach($arr as list($a,$b)){
        echo $a,"\t",$b,PHP_EOL;
    }
}


namespace Name\Dereferencing{
    echo [1,2,3][0],PHP_EOL;
    echo 'PHP'[0],PHP_EOL;
}

// 新的常量
const C1 = 1;
const C2 = C1*2;

class MyConst{
    const C3 = C2 + 1;
    const C4 = C1/self::C3;
    const C5 = 'The value is '.self::C3;

    public function fun($args=C1+self::C3){
        return $args;
    }

}

echo (new MyConst)->fun(),PHP_EOL;
echo MyConst::C5;

namespace Name\Args{
    //before PHP 5.6
    function fun(){
        //func_num_args()函数获取函数参数的个数 
        $args = func_num_args(); 
        echo "Number of arguments: ",$args,PHP_EOL;

        for($i=0;$i<$args;$i++){
            //func_get_arg(int)获取某个索引位置的参数值
            echo "Argument ",$i, " is: ",func_get_arg($i),PHP_EOL;
        }

        echo "*********************",PHP_EOL;
        //func_get_args()获取参数列表
        $argv = func_get_args();
        foreach($argv as $key=>$value){
            echo "argument ",$key,": ",$value,PHP_EOL;
        }
    }

    fun(1,2,3);
    fun('a','b','c');

    //PHP 5.6
    // 通过...运算符定义变长参数函数 
    function func(...$params){
        foreach($params as $key=>$value){
            echo "argument ",$key," :",$value,PHP_EOL;
        }
    }


    echo "---------------------------------",PHP_EOL;
    func(1,2,3);
    func('a','b','c');

    $args = [10,11,12,13];
    //使用...运算符进行参数展开（在调用函数的时候，使用...运算符，将数组和可遍历对象展开为函数参数）
    func(...$args);
}

namespace Name\Operation{
    //使用 ** 进行幂运算
    echo 2**3,PHP_EOL;
    echo 2**8,PHP_EOL;
}



namespace Name\Outer{
    const TITLE = 'hello,world';
    function func(){
        echo __FUNCTION__,PHP_EOL;
    }
}

namespace Name\Test{

    //通过use运算符倒入外部的函数和常量
    use const Name\Outer\TITLE; //通过use const 导入常量
    use function Name\Outer\func; //通过use function 导入函数

    echo TITLE,PHP_EOL;
    func();
}

echo PHP_VERSION,"\n";

echo PHP_OS,"\n";

echo PHP_SAPI,"\n";

echo PHP_EOL,"\n";

echo PHP_INT_MAX,PHP_EOL;

echo PHP_INT_SIZE,PHP_EOL;

echo DEFAULT_INCLUDE_PATH,PHP_EOL;

echo PEAR_INSTALL_DIR,PHP_EOL;

echo PEAR_EXTENSION_DIR,PHP_EOL;

echo PHP_EXTENSION_DIR,PHP_EOL;

echo PHP_PREFIX,PHP_EOL;

echo PHP_BINDIR,PHP_EOL;

echo PHP_LIBDIR,PHP_EOL;

echo PHP_DATADIR,PHP_EOL;

echo PHP_SYSCONFDIR,PHP_EOL;

echo PHP_LOCALSTATEDIR,PHP_EOL;

echo PHP_CONFIG_FILE_PATH,PHP_EOL;

echo PHP_CONFIG_FILE_SCAN_DIR,PHP_EOL;

echo PHP_SHLIB_SUFFIX,PHP_EOL;

echo PHP_OUTPUT_HANDLER_START,PHP_EOL;

echo PHP_OUTPUT_HANDLER_CONT,PHP_EOL;

echo PHP_OUTPUT_HANDLER_END,PHP_EOL;

echo E_ERROR,PHP_EOL;

echo E_WARNING,PHP_EOL;

echo E_PARSE,PHP_EOL;

echo E_NOTICE,PHP_EOL;

echo E_CORE_ERROR,PHP_EOL;

echo E_CORE_WARNING,PHP_EOL;

echo E_COMPILE_ERROR,PHP_EOL;

echo E_COMPILE_WARNING,PHP_EOL;

echo E_USER_ERROR,PHP_EOL;

echo E_USER_NOTICE,PHP_EOL;

echo E_USER_WARNING,PHP_EOL;

echo E_ALL,PHP_EOL;

echo E_STRICT,PHP_EOL;

echo __LINE__,PHP_EOL;

echo __FILE__,PHP_EOL;

echo __DIR__,PHP_EOL;

echo __FUNCTION__,PHP_EOL;

echo __CLASS__,PHP_EOL;

echo __TRAIT__,PHP_EOL;

echo __METHOD__,PHP_EOL;

echo __NAMESPACE__,PHP_EOL;

/* 1.虽然任意合法的PHP代码都可以包含在命名空间中，但只有三种类型的代码受命名空间的影响，它们是：类，函数和常量
   2.命名空间通过关键字namespace 来声明。如果一个文件中包含命名空间，它必须在其它所有代码之前声明命名空间
   3.在声明命名空间之前唯一合法的代码是用于定义源文件编码方式的 declare 语句。另外，所有非 PHP 代码包括空白符
   都不能出现在命名空间的声明之前
   4.同一个命名空间可以定义在多个文件中，即允许将同一个命名空间的内容分割存放在不同的文件中
   5.可以在同一个文件中定义多个命名空间*/

//方式一定义多个命名空间
namespace MyNamespace;

const OK = 1;
class Test{

    public function test(){
        echo "Test->test()",PHP_EOL;
    }
}

function test(){
    echo "test",PHP_EOL;
}

// PHP 命名空间也允许指定层次化的命名空间的名称
namespace Name\MyNamespace;

const OK = 1;
class Test{

  public function test(){
    echo "Test->test()",PHP_EOL;
  }
}

function test(){
  echo "test",PHP_EOL;
}


//方式二定义多个命名空间,推荐使用大括号的方式在同一个文件中定义多个命名空间
namespace MyNamespace{

  const OK = 1;
  class Test{

    public function test(){
      echo "Test->test()",PHP_EOL;
    }
  }

  function test(){
    echo "test",PHP_EOL;
  }
}

// PHP 命名空间也允许指定层次化的命名空间的名称
namespace Name\MyNamespace{

  const OK = 1;
  class Test{

    public function test(){
      echo "Test->test()",PHP_EOL;
    }
  }

  function test(){
    echo "test",PHP_EOL;
  }
}


/* 1.在实际的编程实践中，非常不提倡在同一个文件中定义多个命名空间。这种方式的主要用于将多个 PHP 脚本合并在同一个文件中。
   2.将全局的非命名空间中的代码与命名空间中的代码组合在一起，只能使用大括号形式的语法。全局代码必须用一个不带名称的
   namespace 语句加上大括号括起来
   3.除了开始的declare语句外，命名空间的括号外不得有任何PHP代码 */

declare(encoding='UTF-8');
namespace MyProject {
  const CONNECT_OK = 1;
  class Connection { /* ... */ }
  function connect() { /* ... */  }
}

namespace { // 全局代码
  session_start();
  $a = MyProject\connect();
  echo MyProject\Connection::start();
}


namespace Foo\Bar\Sub{
    const FOO = 1;
    function foo(){
      echo "Foo|Bar|Sub|foo()",PHP_EOL;
    }

    class foo{
      static function func(){
         echo "Foo|Bar|Sub|foo|func()",PHP_EOL;
      }
    }

}


namespace Foo\Bar{
    const FOO = 2;
    function foo(){
       echo "Foo|Bar|foo()",PHP_EOL;
    }

    class foo{
       static function func(){
          echo "Foo|Bar|foo|func()",PHP_EOL;
       }
    }

    foo();    // Foo|Bar|foo()
    foo::func(); // Foo|Bar|foo|func()
    echo FOO,PHP_EOL;   // 2

    echo "*************************",PHP_EOL;
    Sub\foo();  // Foo|Bar|Sub|foo()
    Sub\foo::func();  // Foo|Bar|Sub|foo|func()
    echo Sub\FOO,PHP_EOL; // 1

    echo "++++++++++++++++++++++++++",PHP_EOL;
    \Foo\Bar\foo();   // Foo|Bar|foo()
    \Foo\Bar\foo::func(); // Foo|Bar|foo|func()
    echo \Foo\Bar\FOO,PHP_EOL;  // 2

    //注意访问任意全局类、函数或常量，都可以使用完全限定名称
    echo \strlen("hello,world!"),PHP_EOL;
}


/* PHP 命名空间的实现受到其语言自身的动态特征的影响,必须使用完全
限定名称（包括命名空间前缀的类名称）。注意因为在动态的类名称、函数名称或
常量名称中，限定名称和完全限定名称没有区别，因此其前导的反斜杠是不必要的 */

namespace NameSpaceTest;

class ClassName{
   function __construct(){
      echo __METHOD__,PHP_EOL;
   }
}

function funcname(){
    echo __FUNCTION__,PHP_EOL;
}

const constname = "namespaced";

//$a = 'ClassName';  //报错
$a = '\NameSpaceTest\ClassName';
$obj = new $a;
$a2 = 'NameSpaceTest\ClassName';
$obj2 = new $a2;
//$b = 'funcname';  //报错
$b = '\NameSpaceTest\funcname';
$b2 = 'NameSpaceTest\funcname';
$b();
$b2();
//echo constant('constname'),PHP_EOL; // warnning
echo constant('\NameSpaceTest\constname'),PHP_EOL;
echo constant('NameSpaceTest\constname'),PHP_EOL;


/* 1.PHP支持两种抽象的访问当前命名空间内部元素的方法，__NAMESPACE__ 魔术常量和
    namespace关键字
   2.常量__NAMESPACE__的值是包含当前命名空间名称的字符串。在全局的，不包括在任何命名
    空间中的代码，它包含一个空的字符串。
   3.常量 __NAMESPACE__ 在动态创建名称时很有用
   4.关键字 namespace 可用来显式访问当前命名空间或子命名空间中的元素。它等价于类中
     的 self 操作符 */

namespace MyProject1{
    echo __NAMESAPCE__,PHP_EOL;

}

namespace MyProject2{
   function get($className){
      $a = __NAMESPACE__.'\\'.$className;
      return new $a;
   }
}

namespace MyProject3{
  // see "Using namespaces: importing/aliasing"
  use blah\blah as mine;

  // calls function MyProject\blah\mine()
  blah\mine();

  // calls function MyProject\blah\mine()
  namespace\blah\mine();

  // calls function MyProject\func()
  namespace\func();
  // calls function MyProject\sub\func()
  namespace\sub\func();
  // calls static method "method" of class MyProject\cname
  namespace\cname::method();
  // instantiates object of class MyProject\sub\cname
  $a = new namespace\sub\cname();

  // assigns value of constant MyProject\CONSTANT to $b
  $b = namespace\CONSTANT;
}

/* 1.允许通过别名引用或导入外部的完全限定名称，是命名空间的一个重要特征
   2.PHP 命名空间支持 有两种使用别名或导入方式：为类名称使用别名，或为命名空间名称使用别名
   3.PHP不支持导入函数或常量
   4.在PHP中，别名是通过操作符 use 来实现的 */

namespace foo{
   use My\Full\ClassName as Another;

   use My\Full\NSname;

   use \ArrayObject;

   // 实例化 foo\Another 对象
   $obj = new namespace\Another;

   // 导入操作是在编译执行的，但动态的类名称、函数名称或常量名称则不是
   // 实例化 My\Full\Classname　对象
   $obj = new Another;
   //实例化一个 Another类的对象
   $name = 'Another';
   $obj1 = new $name;

   // 调用函数 My\Full\NSname\subns\func
   NSname\subns\func();

   // 实例化 ArrayObject 对象
   //// 如果不使用 "use \ArrayObject" ，则实例化一个 foo\ArrayObject 对象
   $a = new ArrayObject(array(1));

   /* 注意对命名空间中的名称（包含命名空间分隔符的完全限定名称如 Foo\Bar以及相对的不包含
    命名空间分隔符的全局名称如 FooBar）来说，前导的反斜杠是不必要的也不允许有反斜杠，因为
    导入的名称必须是完全限定的，不会根据当前的命名空间作相对解析 */
   // 导入操作只影响非限定名称和限定名称。完全限定名称由于是确定的，故不受导入的影响。
   //为了简化操作，PHP还支持在一行中使用多个use语句
   use My\Name as Myn,My\Full\Name;
}


/* 如果没有定义任何命名空间，所有的类与函数的定义都是在全局空间，与 PHP 引入命名空间概念
  前一样。在名称前加上前缀 \ 表示该名称是全局空间中的名称，即使该名称位于其它的命名空间中
  时也是如此。 */

namespace A\B\C{
  function fopen(){
     $f = \fopen(...); //调用全局函数 fopen();
     return $f;
  }
}


/* 在一个命名空间中，当 PHP 遇到一个非限定的类、函数或常量名称时，它使用不同的
   优先策略来解析该名称。类名称总是解析到当前命名空间中的名称。因此在访问系统内部
   或不包含在命名空间中的类名称时，必须使用完全限定名称 */

namespace A\B\C;
class Exception extends \Exception {}

// $a 是类 A\B\C\Exception 的一个对象
$a = new Exception('hi');

// $b 是类 Exception 的一个对象
$b = new \Exception('hi');

// 致命错误, 找不到 A\B\C\ArrayObject 类
$c = new ArrayObject;

/* 对于函数和常量来说，如果当前命名空间中不存在该函数或常量，PHP 会退而使用
   全局空间中的函数或常量 */

namespace A\B\C{

  const E_ERROR = 45;
  function strlen($str)
  {
   return \strlen($str) - 1;
  }

  echo E_ERROR, "\n"; // 输出 "45"
  echo INI_ALL, "\n"; // 输出 "7" - 使用全局常量 INI_ALL

  echo strlen('hi'), "\n"; // 输出 "1"
  if (is_array('hi')) { // 输出 "is not array"
   echo "is array\n";
  } else {
   echo "is not array\n";
  }
}

/* 命名空间名称定义
非限定名称Unqualified name
名称中不包含命名空间分隔符的标识符，例如 Foo

限定名称Qualified name
名称中含有命名空间分隔符的标识符，例如 Foo\Bar

完全限定名称Fully qualified name
名称中包含命名空间分隔符，并以命名空间分隔符开始的标识符，例如 \Foo\Bar。
namespace\Foo 也是一个完全限定名称。 */

//名称解析遵循下列规则
/*
1.对完全限定名称的函数，类和常量的调用在编译时解析。例如 new \A\B 解析为类 A\B。
2.所有的非限定名称和限定名称（非完全限定名称）根据当前的导入规则在编译时进行转换。例如，如果命名空间 A\B\C 被导入为 C，那么对 C\D\e() 的调用就会被转换为 A\B\C\D\e()。
3.在命名空间内部，所有的没有根据导入规则转换的限定名称均会在其前面加上当前的命名空间名称。例如，在命名空间 A\B 内部调用 C\D\e()，则 C\D\e() 会被转换为 A\B\C\D\e() 。
4.非限定类名根据当前的导入规则在编译时转换（用全名代替短的导入名称）。例如，如果命名空间 A\B\C 导入为C，则 new C() 被转换为 new A\B\C() 。
5.在命名空间内部（例如A\B），对非限定名称的函数调用是在运行时解析的。例如对函数 foo() 的调用是这样解析的：
  a.在当前命名空间中查找名为 A\B\foo() 的函数
  b.尝试查找并调用 全局(global) 空间中的函数 foo()。
6.在命名空间（例如A\B）内部对非限定名称或限定名称类（非完全限定名称）的调用是在运行时解析的。下面是调用 new C() 及 new D\E() 的解析过程： new C()的解析:
  a.在当前命名空间中查找A\B\C类。
  b.尝试自动装载类A\B\C。
7.new D\E()的解析:
  a.在类名称前面加上当前命名空间名称变成：A\B\D\E，然后查找该类。
  b.尝试自动装载类 A\B\D\E。
为了引用全局命名空间中的全局类，必须使用完全限定名称 new \C() */

namespace A{
  use B\D, C\E as F;

  // 函数调用

  foo();      // 首先尝试调用定义在命名空间"A"中的函数foo()
  // 再尝试调用全局函数 "foo"

  \foo();     // 调用全局空间函数 "foo"

  my\foo();   // 调用定义在命名空间"A\my"中函数 "foo"

  F();        // 首先尝试调用定义在命名空间"A"中的函数 "F"
  // 再尝试调用全局函数 "F"

  // 类引用

  new B();    // 创建命名空间 "A" 中定义的类 "B" 的一个对象
  // 如果未找到，则尝试自动装载类 "A\B"

  new D();    // 使用导入规则，创建命名空间 "B" 中定义的类 "D" 的一个对象
  // 如果未找到，则尝试自动装载类 "B\D"

  new F();    // 使用导入规则，创建命名空间 "C" 中定义的类 "E" 的一个对象
  // 如果未找到，则尝试自动装载类 "C\E"

  new \B();   // 创建定义在全局空间中的类 "B" 的一个对象
  // 如果未发现，则尝试自动装载类 "B"

  new \D();   // 创建定义在全局空间中的类 "D" 的一个对象
  // 如果未发现，则尝试自动装载类 "D"

  new \F();   // 创建定义在全局空间中的类 "F" 的一个对象
  // 如果未发现，则尝试自动装载类 "F"

  // 调用另一个命名空间中的静态方法或命名空间函数

  B\foo();    // 调用命名空间 "A\B" 中函数 "foo"

  B::foo();   // 调用命名空间 "A" 中定义的类 "B" 的 "foo" 方法
  // 如果未找到类 "A\B" ，则尝试自动装载类 "A\B"

  D::foo();   // 使用导入规则，调用命名空间 "B" 中定义的类 "D" 的 "foo" 方法
  // 如果类 "B\D" 未找到，则尝试自动装载类 "B\D"

  \B\foo();   // 调用命名空间 "B" 中的函数 "foo"

  \B::foo();  // 调用全局空间中的类 "B" 的 "foo" 方法
  // 如果类 "B" 未找到，则尝试自动装载类 "B"

  // 当前命名空间中的静态方法或函数

  A\B::foo();   // 调用命名空间 "A\A" 中定义的类 "B" 的 "foo" 方法
  // 如果类 "A\A\B" 未找到，则尝试自动装载类 "A\A\B"

  \A\B::foo();  // 调用命名空间 "A\B" 中定义的类 "B" 的 "foo" 方法
  // 如果类 "A\B" 未找到，则尝试自动装载类 "A\B"
}


//使用 self:: 或者 __CLASS__ 对当前类的静态引用，取决于定义当前方法所在的类
namespace StaticTest{

    class A{
        public static function who(){
            echo __CLASS__,PHP_EOL;
        }

        public static function test(){
            self::who();
        }
    }

    class B extends A{
        public static function who(){
            echo __CLASS__,PHP_EOL;
        }
    }

    B::test();
}

/* 后期静态绑定本想通过引入一个新的关键字表示运行时最初调用的类来绕过限制。
简单地说，这个关键字能够让你在上述例子中调用 test() 时引用的类是 B 而不是 A。
最终决定不引入新的关键字，而是使用已经预留的 static 关键字 */

namespace StaticTest1{
   class A{
      public static function who(){
          echo __CLASS__,PHP_EOL;
      }

      public static function test(){
          static::who();
      }

   }

   class B extends A{
      public static function who(){
          echo __CLASS__,PHP_EOL;
      }
   }

   B::test();
}


/* 在非静态环境下，所调用的类即为该对象实例所属的类。由于 $this-> 会在同一作用
   范围内尝试调用私有方法，而 static:: 则可能给出不同结果。另一个区别是
   static:: 只能用于静态属性 */

namespace StaticTest2{
    class A{
       private function foo(){
          echo "success!",PHP_EOL;
       }

       public function test(){
          $this->foo();
          static::foo();
       }
    }

    class B extends A{

    }

    class C extends A{
       private function foo(){

       }
    }

    $b = new B();
    $b->test();

    $c = new C();
    //$c->test();  // fails, Fatal error
}

/* 后期静态绑定的解析会一直到取得一个完全解析了的静态调用为止。另一方面，如果静态调用使用
   parent:: 或者 self:: 将转发调用信息 */

namespace staticTest3{
  class A {
     public static function foo(){
        static::who();
     }

     public static function who(){
        echo __CLASS__,PHP_EOL;
     }

  }

  class B extends A{
     public static function test(){
        A::foo();
        parent::foo();
        self::foo();
     }

     public static function who(){
        echo __CLASS__,PHP_EOL;
     }
  }

  class C extends B{
     public static function who(){
        echo __CLASS__,PHP_EOL;
     }
  }

  C::test();
}