PHP面向对象中常用的关键字和魔术方法

PHP面向对象中常用的关键字

final
        1.final不能修饰成员属性（类中常量不是用这个关键字）
        2.final只能修饰类和方法

作用：
            使用final修饰的类不能被子类继承
            使用final修饰的方法不能被子类覆盖

用来限制类不被继承，方法不被覆盖就使用final

<?php
//final修饰的类不能被继承
final class Person{
    var $name;
    var $age;
    var $sex;

    function __construct($name,$age,$sex){
        $this->name=$name;
        $this->age=$age;
        $this->sex=$sex;
    }

    function fun1(){
        echo $this->name;
    }
}

//Student类继承类用final修饰的Person类，所以会报错
class Student extends Person{
}

$stu=new Student("zs",20,"nan");

$stu->fun1();
?>

static（静态关键字）
        1.使用static可以修饰成员属性和成员方法，不能修饰类
        2.用static修饰的成员属性，可以被同一个类的所有对象共享
        3.静态的数据是存在内存中的数据段中（初始化静态段）
        4.静态的数据是在类被第一次加载时分配到内存中的，以后再用到类时就直接从数据段中获取
        5.什么是类被加载？只要在程序中使用到这个类（有这个类名出现）
        6.静态方法（static修饰的方法），不能访问非静态的成员（在非静态方法中可以访问静态成员）
            因为非静态的成员，就必须用对象来访问，访问内部成员使用的就是$this，而静态方法不用使用对象调用，也就没有对象，$this也就不能代表对象，非静态的成员还必须使用对象
            如果你确定一个方法中不使用非静态成员，则可以将这个方法声明为即静态方法

注意：静态的成员都要使用类名去访问，不要创建对象，不用对象访问

类名::静态成员

如果在类中使用静态成员，可以使用self代表本类
    const
        1.它只能修饰成员属性
        2.类中声明常量属性使用const
        3.访问方式和static静态成员属性一样（在类外部使用  类名::常量   在类内部使用 self::常量）
        4.常量一定要在声明的时候就给初值

<?php
//定义一个类“人们”
class Person{
    protected $name;
    protected $age;
    protected $sex;
    static $country="中国";
    //声明一个常量
    const RUN="走";

    //构造方法
    function __construct($name,$age,$sex){
        $this->name=$name;
        $this->age=$age;
        $this->sex=$sex;
    }

    function getCountry(){
        //如果在类中使用静态成员，可以使用self代表本类
        return self::$country;
    }

    function say(){
        echo "我的名字：{$this->name}，我的年龄：{$this->age}，我的性别：{$this->sex}。<br>";
    }

    protected function eat(){
        echo "吃饭！<br>";
    }

    function run(){
        //在类的内部使用常量  self::常量
        echo self::RUN."<br>";
    }

    //声明静态的方法
    static function hello(){
        echo "你好<br>";
    }
}

PHP面向对象中常用的魔术方法
    __call()
        作用：调用对象中不存在的方法时，就会出现系统报错，然后程序退出。
        什么时候自动调用：就会在调用一个对象中不存在的方法时就会自动调用
        处理一些不存在的错误调用
        这个方法需要两个参数

<?php
//定义一个类“人们”
class Person{
    protected $name;
    protected $age;
    protected $sex;
    static $country="中国";
    //声明一个常量
    const RUN="走";

    //构造方法
    function __construct($name,$age,$sex){
        $this->name=$name;
        $this->age=$age;
        $this->sex=$sex;
    }

    function getCountry(){
        //如果在类中使用静态成员，可以使用self代表本类
        return self::$country;
    }

    function say(){
        echo "我的名字：{$this->name}，我的年龄：{$this->age}，我的性别：{$this->sex}。<br>";
    }

    protected function eat(){
        echo "吃饭！<br>";
    }

    function run(){
        //在类的内部使用常量  self::常量
        echo self::RUN."<br>";
    }

    //处理一些不存在的错误调用
    //就会在调用一个对象中不存在的方法时就会自动调用
    function __call($methodName,$args){
        //$methodName调用不存在方法的方法名 $args里面的参数
        echo "你调用的方法{$methodName}（参数：";
        print_r($args);
        echo "）不存在<br>";
    }

    //声明静态的方法
    static function hello(){
        echo "你好<br>";
    }
}

$p=new Person("张三",20,"女");

$p->test(10,20,30);
$p->demo("aa","bb");
$p->say();
?>

__toString()
        直接输出对象引用的时候自动调用，用来快速获取字符串表示的最快捷的方法

<?php
//定义一个类“人们”
class Person{
    protected $name;
    protected $age;
    protected $sex;
    static $country="中国";
    //声明一个常量
    const RUN="走";

    //构造方法
    function __construct($name,$age,$sex){
        $this->name=$name;
        $this->age=$age;
        $this->sex=$sex;
    }

    function say(){
        echo "我的名字：{$this->name}，我的年龄：{$this->age}，我的性别：{$this->sex}。<br>";
    }

    function __toString(){
        return self::$country."<br>{$this->name}<br>{$this->age}<br>{$this->sex}<br>".self::RUN;
    }
}

$p=new Person("张三",21,"女");
echo $p;
?>

__clone()
        克隆对象使用clone()处理
        原本（原来的对象）
        复本（复制出来的对象）
        __clone()就是在克隆对象时自动调用的方法
        只要一个对象一创建，就要有初始化的动作，和构造方法__constuct作用相似
        在__clone()方法中的$this关键字代表的是复本的对象,$that代表原本对象

<?php
//定义一个类“人们”
class Person{
    var $name;
    protected $age;
    protected $sex;
    static $country="中国";
    //声明一个常量
    const RUN="走";

    //构造方法
    function __construct($name,$age,$sex){
        $this->name=$name;
        $this->age=$age;
        $this->sex=$sex;
    }

    function say(){
        echo "我的名字：{$this->name}，我的年龄：{$this->age}，我的性别：{$this->sex}。<br>";
    }

    function __clone(){
        $this->name="王五";
        $this->age=18;
        $this->sex="男";
    }

    function __destruct(){
        echo $this->name."<br>";
    }
}

$p=new Person("张三",21,"女");
$p->say();
//这并不能叫做克隆对象，因为在析构时只析构一次
/*$p1=$p;
$p1->name="李四";
$p1->say();*/

$p1= clone $p;
$p1->say();
?>

__autoload()
        注意：其它的魔术方法都是在类中添加起作用，这是唯一一个不在类中添加的方法
        只要在页面中使用到一个类，只要用到类名，就会自动将这个类名传给这个参数

<?php
function __autoload($className){
    include "./test/".$className.".class.php";
}

    $o=new One;
    $o->fun1();    

    $t=new Two;
    $t->fun2();

    $h=new Three;
    $h->fun3();

?>

test里的文件

one.class.php

<?php
class One{
    function fun1(){
        echo "The Class One<br>";
    }
}
?>

two.class.php

<?php
class Two{
    function fun2(){
        echo "The Class Two<br>";
    }
}
?>

three.class.php

<?php
class Three{
    function fun3(){
        echo "The Class Three<br>";
    }
}
?>

对象串行化（序列化）：将一个对象转为二进制串（对象是存储在内存中的，容易释放）
        使用时间：
            1.将对象长时间存储在数据库或文件中时
            2.将对象在多个PHP文件中传输时

serialize();    参数是一个对象，返回来的就是串行化后的二进制串
        unserialize();  参数就是对象的二进制串，返回来的就是新生成的对象
    __sleep()
        是在序列化时调用的方法
        作用：就是可以将一个对象部分串行化
            只要这个方法中返回一个数组，数组中有几个成员属性就序列化几个成员属性，如果不加这个方法，则所有成员都被序列化
    __wakeup()
        是在反序列化时调用的方法
        也是对象重新诞生的过程

<?php
//定义一个类“人们”
class Person{
    var $name;
    protected $age;
    protected $sex;
    static $country="中国";
    //声明一个常量
    const RUN="走";

    //构造方法
    function __construct($name,$age,$sex){
        $this->name=$name;
        $this->age=$age;
        $this->sex=$sex;
    }

    function say(){
        echo "我的名字：{$this->name}，我的年龄：{$this->age}，我的性别：{$this->sex}。<br>";
    }

    function __clone(){
        $this->name="王五";
        $this->age=18;
        $this->sex="男";
    }

    //是在序列化时调用的方法，可以部分串行化对象
    function __sleep(){
        return array("name","age");
    }

    //是在反序列化时调用的方法，也是对象重新诞生的过程。可以改变里面的值
    function __wakeup(){
        $this->name="sanzhang";
        $this->age=$this->age+1;
    }

    function __destruct(){

    }
}
?>

read.php

<?php
    require "11.php";

    $str=file_get_contents("mess.txt");
    $p=unserialize($str);

    echo $p->say();
?>

write.php

<?php
    require "11.php";

    $p=new Person("张三",18,"男");

    $str=serialize($p);

    file_put_contents("mess.txt",$str);
?>