PHP动态地创建属性和方法, 对象的复制, 对象的比较,加载指定的文件,自动加载类文件,命名空间

5年以前 | 阅读数：843 次 | 编程语言：PHP

PHP前言：

•动态地创建属性和方法

•对象的复制

•对象的比较

•加载指定的文件

•自动加载类文件

•命名空间

示例

1、类的相关知识点 3（动态地创建属性和方法）

class/class3.php


    <?php
    /**
    * 类的相关知识点 3（动态地创建属性和方法）
    */
    // 用于演示如何动态地创建属性（这就是 php 中所谓的重载）
    class Class1
    {
    // __set 魔术方法，当设置的属性不存在或者不可访问（private）时就会调用此函数
    public function __set($name, $value)
    {
    echo "__set \$name: {$name}, \$value: {$value}";
    echo "<br />";
    }
    // __get 魔术方法，当获取的属性不存在或者不可访问（private）时就会调用此函数
    public function __get($name)
    {
    echo "__get \$name: {$name}";
    echo "<br />";
    return 999;
    }
    }
    $objClass1 = new Class1();
    // 当你设置的属性不存在或者不可访问（private）时，就会调用对应的 __set 魔术方法
    $objClass1->property1 = wanglei; // 不可访问的如 private ，或者不存在的
    // 当你获取的属性不存在或者不可访问（private）时，就会调用对应的 __get 魔术方法
    echo $objClass1->property2;
    echo "<br />";
    // 用于演示如何动态地创建方法（这就是 php 中所谓的重载）
    class Class2
    {
    // __call 魔术方法，当调用的实例方法不存在或者不可访问（private）时就会调用此函数
    public function __call($name, $arguments)
    {
    echo "__call \$name: {$name}, \$arguments: " . implode(', ', $arguments);
    echo "<br />";
    }
    // __callStatic 魔术方法，当调用的类方法不存在或者不可访问（private）时就会调用此函数
    public static function __callStatic($name, $arguments)
    {
    echo "__callStatic \$name: {$name}, \$arguments: " . implode(', ', $arguments);
    echo "<br />";
    }
    }
    $objClass2 = new Class2();
    // 当你调用的实例方法不存在或者不可访问（private）时，就会调用对应的 __call 魔术方法
    echo $objClass2->method1("aaa", "bbb");
    // 当你调用的类方法不存在或者不可访问（private）时，就会调用对应的 __callStatic 魔术方法
    echo Class2::method2("aaa", "bbb");

2、类的相关知识点 4（对象的复制，对象的比较）

class/class4.php


    <?php
    /**
    * 类的相关知识点 4（对象的复制，对象的比较）
    */
    // 用于演示如何复制对象
    class Class1
    {
    public $field1 = "field1";
    public $field2 = "field2";
    // 通过 clone 复制对象时，会调用此魔术方法
    function __clone()
    {
    echo "__clone";
    echo "<br />";
    }
    }
    $objClass1 = new Class1();
    // 通过 clone 复制对象，会调用 __clone 魔术方法
    $objClass2 = clone $objClass1;
    // 通过 clone 复制的对象为浅拷贝（shallow copy），即成员数据之间的一一赋值, 而所有的引用属性仍然会是一个指向原来的变量的引用（如果要做 deep copy 则需要自己写）
    echo $objClass2->field1; // output: field1
    echo "<br />";
    echo $objClass2->field2; // output: field2
    echo "<br />";
    // 如果两个对象的属性和属性值都相等，则他们"=="相等，
    if ($objClass1 == $objClass2)
    {
    echo '$objClass1 == $objClass2';
    echo "<br />";
    }
    // 如果两个对象的属性和属性值都相等，但不是同一个类的实例，则他们"==="不相等
    if ($objClass1 !== $objClass2)
    {
    echo '$objClass1 !== $objClass2';
    echo "<br />";
    }
    // 如果两个对象是同一个类的实例，则他们"==="相等
    if ($objClass1 === $objClass1)
    {
    echo '$objClass1 === $objClass1';
    echo "<br />";
    }
    // 如果两个对象是同一个类的实例，则他们"==="相等
    $objClass3 = &$objClass1;
    if ($objClass1 === $objClass3)
    {
    echo '$objClass1 === $objClass3';
    echo "<br />";
    }

3、类的相关知识点 5（加载指定的文件，自动加载类文件）

class/class5.php


    <?php
    /**
    * 类的相关知识点 5（加载指定的文件，自动加载类文件）
    */
    /*
    * 包含并运行指定文件，可以是绝对路径也可以是相对路径
    * include 找不到的话则警告，然后继续运行（include_once: 在当前文件中只 include 指定文件一次）
    * require 找不到的话则错误，然后终止运行（require_once: 在当前文件中只 require 指定文件一次）
    * include '';
    * require '';
    * include_once '';
    * require_once '';
    */
    // 演示如何通过 __autoload 魔术方法，来实现类的自动加载
    function __autoload($class_name)
    {
    // 加载指定的文件
    require_once $class_name . '.class.php';
    }
    // 如果在当前文件中找不到 MyClass 类，那么就会去调用 __autoload 魔术方法
    $obj = new MyClass();
    echo $obj->name;
    echo "<br />"; 
    class/MyClass.class.php
    <?php
    class MyClass
    {
    public $name = "webabcd";
    }

4、类的相关知识点 6（命名空间）

class/class6.php


    <?php
    /**
    * 类的相关知识点 6（命名空间）
    */
    // 以下代码仅用于演示，实际项目中不建议在一个文件中定义多个 namespace
    // 如果当前文件中只有一个命名空间，那么下面的这段可以省略掉命名空间的大括号，直接 namespace MyNamespace1; 即可
    namespace MyNamespace1
    {
    const MyConst = "MyNamespace1 MyConst";
    function myFunction()
    {
    echo "MyNamespace1 myFunction";
    echo "<br />";
    }
    class MyClass
    {
    public function myMethod()
    {
    echo "MyNamespace1 MyClass myMethod";
    echo "<br />";
    }
    }
    }
    // 定义命名空间时，可以指定路径
    namespace Sub1\Sub2\MyNamespace2
    {
    const MyConst = "MyNamespace2 MyConst";
    function myFunction()
    {
    echo "MyNamespace2 myFunction";
    echo "<br />";
    }
    class MyClass
    {
    public function myMethod()
    {
    echo "MyNamespace2 MyClass myMethod";
    echo "<br />";
    }
    }
    }
    namespace MyNamespace3
    {
    // 调用指定命名空间中的指定常量
    echo \MyNamespace1\MyConst;
    echo "<br />";
    // 调用指定命名空间中的指定函数
    \MyNamespace1\myFunction();
    // 实例化指定命名空间中的类
    $obj1 = new \MyNamespace1\MyClass();
    $obj1->myMethod();
    }
    namespace MyNamespace4
    {
    // use 指定的命名空间
    use \Sub1\Sub2\MyNamespace2;
    // 之后不用再写全命名空间的路径了，因为之前 use 过了
    echo MyNamespace2\MyConst;
    echo "<br />";
    MyNamespace2\myFunction();
    $obj1 = new MyNamespace2\MyClass();
    $obj1->myMethod();
    }
    namespace MyNamespace5
    {
    // use 指定的命名空间，并为其设置别名
    use \Sub1\Sub2\MyNamespace2 as xxx;
    // 之后再调用命名空间时，可以使用其别名
    echo xxx\MyConst;
    echo "<br />";
    xxx\myFunction();
    $obj1 = new xxx\MyClass();
    $obj1->myMethod();
    }

以上所述是小编给大家介绍的PHP动态地创建属性和方法, 对象的复制, 对象的比较, 加载指定的文件, 自动加载类文件, 命名空间的相关介绍，希望对大家有所帮助！