类的关键字、魔术方法与单态设计模式

一、面向对象的关键字

1.instanceof操作符：

对象是否属于类（检测继承性），如下：

    class Person {};
    class Student extends Person {};
    $p=new Person;
    $s=new Student;
    echo $p instanceof Student;//false
    echo $s instanceof Student;//true
    echo $s instanceof Person;//true

2.final关键字：

不定义常量，不能使用final修饰成员属性

    a.final可以修饰类，该类不能扩展（不能有子类），即最终类，如下：

    final class Person {......};

    b.final可以修饰方法，这个方法不能在子类中被覆盖（不能被扩展），即最终方法，如下：

    public final function say(){......};
    //子类不能用parent::say();调用

3.static关键字：

    a.将一个类中多个实例对象的共用属性/方法存入初始化静态段中，节省内存空间
    b.类第一次出现，加载时，已将static成员加载到了内存，即不创建实例对象，也可以访问该成员//echo Person::country
    c.静态成员一定要使用类来访问//echo Person::country
    d.静态成员可以访问也可以赋值，赋值后所有实例都变化，self关键字可以在本类中代表本类名，类似this
    e.静态成员一旦被加载，只有脚本结束才释放    
    f.该关键字可以修饰属性和方法，不能修饰类。方法如无$this的调用，则默认为为静态方法。声明静态方法会有错误提示，但很方便，能用尽量用（效率高）。
    g.上述第f条的缺点如下：
        （1）占内存，脚本结束才释放
        （2）静态方法只能使用静态属性，因为不能使用$this

4.const关键字

a.常量存储区域为初始化静态段
b.define只能在类外部声明常量，内部报错
c.const只能修饰成员属性，即定义常量，注意：
    （1）常量使用大写，不能使用$
    （2）声明时必有初值
    （3）访问方式与static相同（self::name），但只能读
          

二、魔术方法

1.自动调用，只有PHP语言存在
2.以“__”开始
3.方法名固定        
4.如果不写就不存在，也没有默认功能   

1.__toString()：将对象转为自定义的字符串（类似js），该方法不能有参数，必须返回一个字符串（echo/print后常用），如下：

    class Person {
        function __toString(){
            return "$$$$<br>";
        }
    };
    $p=new Person;
    echo $p;//$$$$

2.__clone()：

a.克隆对象

    class Person {
        function __toString(){
            return "$$$$<br>";
        }
    };
    $p=new Person;
    $p2=clone $p;

b.魔术方法：

（1）在克隆对象时自动调用
（2）作用：与构造方法一样，对新克隆的对象初始化
（3）该方法中$this代表副本，可进行初始化（$that有时可代表原本，有的版本能用）

    class Person {
        var $name;
        function __construct($name){
            $this->name=$name;
        }
        function say(){
            echo $this->name."<br>";
        }
        function __clone(){
            $this->name="ni";
        }
    };
    $p=new Person("wo");
    $p->say();//wo
    $p2=clone $p;
    $p2->say();//ni

3.__call()：

a.调用对象中不存在的方法时，自动调用
b.有两个参数，第一个参数不存在的方法名，第二个是不存在方法的参数数组
c.作用：将功能相似方法进行批量处理或对不存在方法完成提示功能

    class Person {
        var $name;
        function __construct($name){
            $this->name=$name;
        }
        function say(){
            echo $this->name."<br>";
        }
        function __clone(){
            $this->name="ni";
        }
        function __call($method,$args){
            echo "方法{$method}()，参数为";
            print_r($args);
            echo"不存在！<br>";
        }
    };
    $p=new Person("wo");
    $p->eat("肉","米");
    //方法eat()，参数为Array ( [0] => 肉 [1] => 米 ) 不存在！

d.可以用来实现重载（与JS函数的arguments方法类似）

class Foo1{
        public function __call($name,$arguments){
                if($name=="doStuff"){
                        /**
                         *实际上，不仅仅可以第一个参数类型，还可以判断参数个数，以及参数顺序，那么就和C++等强数据类型语言的重载效果是一样的了！
                        */
                        if(is_int($arguments[0])){
                                $this->doStuffForInt($arguments[0]);
                        }else if(is_string($arguments[0])){
                                $this->doStuffForString($arguments[0]);
                        }
                }
        }

        private function doStuffForInt($a){
                echo "执行的是doStuffForInt()方法";
        }

        private function doStuffForString($a){
                echo "执行的是doStuffForString()方法";
        }
}

$foo1=new Foo1;

$foo1->doStuff('1');//执行的是doStuffForString()方法

三、单态/单件/单例设计模式

1. 概念：一个类只能创建一个对象，最适合PHP使用的设计模式
2. 方法：

a.先将构造函数私有化，让类不能创建对象，如下：

    class Person {
        private function __construct(){
            
        }
        function __destruct(){
            echo "######<br>";
        }
        function say(){
            echo "$$$$<br>";
        }
    };
    $p=new Person;//报错

b.定义（static）静态方法，在类中创建类的对象，外部使用类调用来创建对象，但这样仍然是每次调用创建一个新对象，而不是只能创建一个对象，具体如下：

    class Person {
        private function __construct(){
            
        }
        static function createObj(){
            $obj=new self;
            return $obj;
        }
        function __destruct(){
            echo "######<br>";
        }
        function say(){
            echo "$$$$<br>";
        }
    };
    $p=Person::createObj();//######
    $p=Person::createObj();//######
    $p=Person::createObj();//######
    $p=Person::createObj();//######
    $p->say();//$$$$

c.将新建对象的变量$obj设定为静态属性（唯一的），即可达到要求，该类只能创建一个对象，如下：

    class Person {
        static $obj=null;
        private function __construct(){
            
        }
        static function createObj(){
            if(is_null(self::$obj)){
                self::$obj=new self;
            }
            return self::$obj;
        }
        function __destruct(){
            echo "######<br>";
        }
        function say(){
            echo "$$$$<br>";
        }
    };
    $p=Person::createObj();
    $p=Person::createObj();
    $p=Person::createObj();
    $p=Person::createObj();
    //由于只创建了一个类，只输出一次######
    $p->say();//$$$$