OOP面向对象学习笔记（2）---基础实践

一：构造函数与析构函数

1. 构造函数：在类被实例化时自动调用的一个函数。主要用来初始化。
2. 析构函数：程序运行结束时（或者对象被销毁时）自动调用的最后一个函数。主要用来释放资源等。
3. code next...

<?php
class Test {
    public function __construct($obj) {
        echo "hello " . $obj . "<br>";
    }
    public function __destruct() {
        echo "bye Test<br>";
    }
}
$obj1 = new Test ( "obj1" );
$obj2 = new Test ( "obj2" );
// 在脚本运行结束时自动调用析构函数
// 输出：hello obj1 hello obj2 bye Test bye Test
// 在对象销毁时，不用等到脚本运行结束，自动调用析构函数
$obj3 = new Test ( "obj3" );
$obj3 = null;
$obj4 = new Test ( "obj4" );
//输出 hello obj3 bye Test hello obj4 bye Test

二：对象的引用

      $james1=&$james 此时$james1和$james同时指向变量的地址。

      比喻：$james1和$james是同一个人，只是不同的名字（大名、小名）。

              $james1是$james的影子。

三：静态成员

1：为什么要使用静态成员？

    为的是让一个类的所有对象都共用这个公共的对象，而不是这个成员属于这个类的某个对象。

    举例：所有的NBA球员都有一个总裁lio，现要更换总裁为david，如何实现呢？下面的方法可以。

<?php 
class Player{
    public $president="lio";
    public function changePresident($pName){
        $this->president=$pName;
    }
}
$jordan=new Player();
$james=new Player();
$jordan->changePresident("tomacs");
$james->changePresident("david");
echo "jame's president is ".$james->president."<br>";
echo "jordan's president is ".$jordan->president."<br>";
//输出：jame's president is david
//     jordan's president is tomacs

显然，james和jordan对象可以使用这个方法随意的更改总裁，这样两者就不能实现共有一个总裁了。

我们可以通过静态成员的额方法实现，将方法变成全局的，不属于某一个对象。

<?php 
class Player{
    public static $president="lio";
    public static function changePresident($pName){
        self::$president=$pName;
    }
}
$jordan=new Player();
$james=new Player();
Player::changePresident("tomacs");
Player::changePresident("david");
echo "jame's president is ".Player::$president."<br>";
echo "jordan's president is ".Player::$president."<br>";
//输出：jame's president is david
//     jordan's president is david

四：魔术方法（PHP特有）

1：__toString() 和 __invoke()

<?php 
class Test{
    //当对象被当做字符串调用时，会自动执行此方法
    public function __toString(){
        //注意，一定要有return
        return "hello,this is string!";
    }
    //当对象被当做函数调用时，会自动执行此方法
    public function __invoke(){
        echo "hello,this is invoke!";
    }
    
}
$obj=new Test();
echo $obj;     //hello,this is string!
$obj();        //hello,this is invoke!

2:__call() 方法重载

<?php 
class Test{
    //当类的方法不存在时自动调用此函数
    public function __call($name,$arg){
        //implode()将数组转换为字符串
        echo "function ". $name ." with param ".implode("---", $arg);
    }
    
}
$obj=new Test();
$obj->test(1,2,3);//function test with param 1---2---3

    延伸：__callstatic()

<?php 
class Test{
    //当类的方法不存在时自动调用此函数
    public static function __callstatic($name,$arg){
        //implode()将数组转换为字符串
        echo "function ". $name ." with param ".implode("---", $arg);
    }
    
}
Test::test(1,2,3);//function test with param 1---2---3

3:__get()、__set()、__isset()、__unset() 属性重载

<?php
class Test {
    private $user="lio";
    //当对象访问不可访问属性时自动调用此函数
    public function __get($name) {
        echo "property ".$name." is denied to access.<br>";
    }
    //当对象为不可赋值属性赋值时，自动调用此方法
    public function __set($name,$value){
        echo "you can not set property ".$name." to value ".$value."<br>";
    }
    //当对不可访问属性使用isset()时，自动调用此方法
    public function __isset($name){
        var_dump(isset($this->$name));
    }
    //当对不可访问属性使用unset()时，自动调用此方法
    public function __unset($name){
        unset($this->$name);
    }
}
$obj=new Test();
$obj->user;           //property user is denied to access.
$obj->user="eric";    //you can not set property user to value eric
isset($obj->user);    //bool(true)
unset($obj->user);

4：__clone()对象克隆

首先明白“克隆”。比如A克隆出B来，则A和B完全相同，但是A和B是两个独立的主体，对象。

举例：现有对象$obj1，如果$obj2=$obj1 ，那么$obj1和$obj2指向同一个对象，不是两个相同的主体。

        解决：可以通过$obj2=clone $obj1 解决。那么$obj1和$obj2就是两个独立的主体了。

问题：如果$obj2想对$obj1变异，怎么办呢？

<?php
class Test {
    public $user="lio";
    //进行变异
    public function __clone(){
         return $this->user="eric";
    }
}
$obj1=new Test();
$obj2=clone $obj1;
echo $obj1->user; //lio
echo $obj2->user; //eric