面向对象——继承2，final, 魔术方法

# 如果父类中的方法被声明为 final，则子类无法覆盖该方法。同样如果一个类被声明为 final，则不能被继承。
* # 析构方法
*      子类重写析构方法后，可以用parent::__XXX()调用父类析构方法
*      __construct($a,$b,$c)：在每次创建新对象时先调用此方法
*      __destruct(): 在销毁对象时调用此方法
*      __call($function_name, $filed)：调用了一个不存在的方法时自动调用
*      __callStatic($function_name, $filed)：调用了一个不存在的静态方法时自动调用（前面要加static）
*      __get($name,$value)：给一个不存在的变量设置值时自动调用

index.php

<?php

/*
 * 继承2，final, 魔术方法
 * # 如果父类中的方法被声明为 final，则子类无法覆盖该方法。同样如果一个类被声明为 final，则不能被继承。
 * # 析构方法
 *      子类重写析构方法后，可以用parent::__XXX()调用父类析构方法
 *      __construct($a,$b,$c)：在每次创建新对象时先调用此方法
 *      __destruct(): 在销毁对象时调用此方法
 *      __call($function_name, $filed)：调用了一个不存在的方法时自动调用
 *      __callStatic($function_name, $filed)：调用了一个不存在的静态方法时自动调用（前面要加static）
 *      __get($name,$value)：给一个不存在的变量设置值时自动调用
 */

include 'car.php';
$car = new car('a','b','c','d','e');
$car2 = new car('a','b','c','d','e');
$bus = new bus('1','2','3');

$car->car1();
// 克隆对象
$car2 = clone $car;
$car2->car1();

$car->car2();
$bus->car1();
$bus->car2();

// 调用一个不存在的方法
$car->asff('123');

\car::abcde('456');

// 给类中不存在的变量设置一个值
$car->aa = 100;

// 获取类中不存在变量的值
echo $car->aa;

// 对不存在对象使用isset
echo isset($car->aa);

// 对不存在对象使用empty
echo empty($car->aa);

// 使用serialize自动调用__sleep
$p = serialize($car);

// unserialize自动调用__wakeup
unserialize($p);

// 对象当字符串使用
echo $car;

// 对象当函数使用
$car();

// 导出
eval('$b= '.var_export($car, true).';');

var_dump($b);

exit;
// 销毁对象
unset($car);
exit;

car.php

<?php

class car // 此行若改为final class car， 则car类不能被继承
{
    public $a = 10;
    //类的成员属性
    private $name;
    private $age;
    private $sex;

    function __construct($pname,$page,$psex,$p4,$p5)
    {

        /*$this->name=$pname;
        $this->age=$page;
        $this->sex=$psex;*/
        echo '这个是析构方法'.$pname.$page.$psex.$p4.$p5.'<br/>';
    }

    function __destruct()
    {
        echo '销毁了一个对象'.'<br/>';
    }

    function __clone()
    {
        echo '克隆了一个对象呢'.'<br/>';
    }

    function __call($function_name, $filed)
    {
        echo '调用了一个不存在的方法：方法名字：'.$function_name.',参数：';
        var_dump($filed);
        echo '<br/>';
    }

    static function __callStatic($function_name, $filed)
    {
        echo '调用了一个不存在的静态方法：方法名字：'.$function_name.',参数：'.'<br/>';
        var_dump($filed);
        echo '<br/>';
    }

    function __set($name, $value)
    {
        echo '给不存在的变量（'.$name.'）设置值了,value:'.$value.'<br/>';
    }

    function __get($name)
    {
        echo '获取不存在变量（'.$name.'）的值'.'<br/>';
    }

    function __isset($name)
    {
        echo '对不存在对象'.$name.'使用isset了'.'<br/>';
    }

    function __sleep()
    {
        echo '使用了serialize<br/>';
        return array('name');
    }

    function __wakeup()
    {
        echo '使用了unserialize<br/>';
    }

    function __toString()
    {
        echo '对象当字符串使用了<br/>';
        return json_encode($this);
    }

    function __invoke()
    {
        echo '对象当函数使用了<br />';
    }

    // 必须是静态方法
    static function __set_state()
    {

        $tmp = new car(1,2,3,4,5);
        $tmp->name = 10;
        return $tmp;
    }

    // var_dump（）对象时调用此方法。
    public function __debugInfo()
    {
        return [
          'age' => 99,
        ];
    }

    // 普通方法
    function car1($s=5,$a=5) {
        static $p = 0;
        echo ++$p;
        //echo 'this is car1';
    }

    // 加final的方法
    final function car2() {
        echo 'this is car2'.'<br/>';
    }
}

class bus extends car
{
    function __construct($p1,$p2,$p3)
    {
        echo '这是bus的析构方法'.$p1.$p2.$p3.'<br/>';
    }

    // 重写父类car1 重写的参数不能比父类的少
    function car1($id=3,$pid=4) {

        echo '重写父类car1'.'<br/>';;
    }

    // 重写父类car2 // 报错，父类方法加了final，不允许重写
    /*function car2() {
        echo '重写父类car2';
    }*/
}

面向对象——继承2，final, 魔术方法

猜你喜欢