PHP 类与对象23
PHP 类与对象
基本概念
面向对象编程（Object Oriented Programming, OOP, 面向对象程序设计）是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。OOP 达到了软件工程的三个目标：重用性、灵活性和扩展性。
PHP 在 4.0 版本之后完善了对 OOP 的支持了。对于小型的应用，使用传统的过程化编程可能更简单也更有效率。然而对于大型的复杂应用时，OOP 就是一个不得不考虑的选择。
类
类是具有相同属性和服务的一组对象的集合。它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和服务两个主要部分。在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性说明和服务说明两个主要部分。
对象
对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。
类与对象的关系就如模具和铸件的关系，类的实例化结果就是对象，而对一类对象的抽象就是类。
关于面向对象的编程涉及的内容很广泛，本教程只介绍基本的概念与在 PHP 中的应用。
类
使用关键字 class 来声明一个类，后面紧跟类的名字，主体用 {} 符号括起来。
语法：
class class_name{
......
}
类里面包含了属性和方法。
属性
通过在类定义中使用关键字 var 来声明变量，即创建了类的属性，也叫类的成员属性。
语法：
class class_name{
var $var_name;
}
举个例子说明，如果定义一个 人 的类，那么人的 姓名、年龄、性别 等等便可以看做 人 这个类的属性。
方法
通过在类定义中声明函数，即创建了类的方法。
语法：
class class_name{
function function_name(arg1,arg2,……)
{
函数功能代码
}
}
类的应用
一个定义了属性和方法的类就是一个完整的类了，可以在一个类里面包含一个完整的处理逻辑。使用 new 关键字来实例化一个对象以便应用类里面的逻辑。可以同时实例化多个对象。
语法：
object = new class_name();
实例化一个对象后，使用 -> 操作符来访问对象的成员属性和方法。
语法：
object->var_name;
object->function_name;
如果要在定义的类里面访问成员的属性或者方法，可以使用伪变量 $this 。$this 用于表示 当前对象 或 对象本身 。
例子：
<?php
class Person {
//人的成员属性
var $name; //人的名字
var $age; //人的年龄
//人的成员 say() 方法
function say() {
echo "我的名字叫：".$this->name."<br />";
echo "我的年龄是：".$this->age;
}
} //类定义结束
//实例化一个对象
$p1 = new Person();
//给 $p1 对象属性赋值
$p1->name = "张三";
$p1->age = 20;
//调用对象中的 say()方法
$p1->say();
?>
运行该例子，输出：
我的名字叫：张三
我的年龄是：20
上面的例子演示了一个简单的基于面向对象的 PHP 应用。
PHP 类的继承 extends 关键字
PHP 类的继承
PHP 类的继承是指建立一个新的派生类，从一个或多个先前定义的类中继承数据和方法，而且可以重新定义或加进新数据和方法，从而建立了类的层次或等级。
我们称已存在的用来派生新类的类为父类，由已存在的类派生出的新类为子类。继承是面向对象的三大特性之一。
通过继承机制，可以利用已有的数据类型来定义新的数据类型。所定义的新的数据类型不仅拥有新定义的成员，而且还同时拥有旧的成员。
注意：不同于 Java 等语言，在 PHP 中，一个类只能直接从一个类中继承数据，即单继承。
使用 extends 关键字来定义类的继承：
class 子类 extends 父类{
}
例子：
<?php
class Person {
var $name;
var $age;
function say() {
echo "我的名字叫：".$this->name."<br />";
echo "我的年龄是：".$this->age;
}
}
// 类的继承
class Student extends Person {
var $school; //学生所在学校的属性
function study() {
echo "我的名子叫：".$this->name."<br />";
echo "我正在".$this->school."学习";
}
}
$t1 = new Student();
$t1->name = "张三";
$t1->school = "人民大学";
$t1->study();
?>
运行该例子，输出：
我的名子叫：张三
我正在人民大学学习
在软件开发中，类的继承性使所建立的软件具有开放性、可扩充性，这是信息组织与分类的行之有效的方法，它简化了对象、类的创建工作量，增加了代码的可重性。采用继承性，提供了类的规范的等级结构。通过类的继承关系，使公共的特性能够共享，提高了软件的重用性。
PHP 构造方法 __construct()
PHP 构造方法 __construct() 允许在实例化一个类之前先执行构造方法。
构造方法
构造方法是类中的一个特殊方法。当使用 new 操作符创建一个类的实例时，构造方法将会自动调用，其名称必须是 __construct() 。
在一个类中只能声明一个构造方法，而是只有在每次创建对象的时候都会去调用一次构造方法，不能主动的调用这个方法，所以通常用它执行一些有用的初始化任务。该方法无返回值。
语法：
function __construct(arg1,arg2,...)
{
......
}
例子：
<?php
class Person {
var $name;
var $age;
//定义一个构造方法初始化赋值
function __construct($name, $sex, $age) {
$this->name=$name;
$this->age=$age;
}
function say() {
echo "我的名字叫：".$this->name."<br />";
echo "我的年龄是：".$this->age;
}
}
$p1=new Person("张三", 20);
$p1->say();
?>
运行该例子，输出：
我的名字叫：张三
的年龄是：20
在该例子中，通过构造方法对对象属性进行初始化赋值。
提示
PHP 不会在本类的构造方法中再自动的调用父类的构造方法。要执行父类的构造方法，需要在子类的构造方法中调用 parent::__construct() 。
PHP 析构方法 __destruct()
PHP 析构方法 __destruct() 允许在销毁一个类之前执行执行析构方法。
析构方法
与构造方法对应的就是析构方法，析构方法允许在销毁一个类之前执行的一些操作或完成一些功能，比如说关闭文件、释放结果集等。析构函数不能带有任何参数，其名称必须是 __destruct() 。
语法：
function __destruct()
{
......
}
我们在上面的例子中加入下面的析构方法：
//定义一个析构方法
function __destruct()
{
echo "再见".$this->name;
}
再次运行该例子，输出：
我的名字叫：张三
的年龄是：20
再见张三
提示
和构造方法一样，PHP 不会在本类中自动的调用父类的析构方法。要执行父类的析构方法，必须在子类的析构方法体中手动调用 parent::__destruct() 。
试图在析构函数中抛出一个异常会导致致命错误。
在 PHP4 版本中，构造方法的名称必须与类名相同，且没有析构方法。
PHP final 关键字
final 关键字
final 关键字用于定义类和方法，该关键字表示该类或方法为最终版本，即该类不能被继承，或该方法在子类中不能被重载（覆盖）。
类使用 final 关键字的例子：
final class Person
{
......
}
final 定义的类被继承时会提示如下错误：
Fatal error: Class Student may not inherit from final class (Person) in ...
方法使用 final 关键字的例子：
class Person
{
final function say()
{
......
}
}
PHP 类的接口 interface 与 implements 关键字
PHP 接口
PHP 类是单继承，也就是不支持多继承，当一个类需要多个类的功能时，继承就无能为力了，为此 PHP 引入了类的接口技术。
如果一个抽象类里面的所有方法都是抽象方法，且没有声明变量，而且接口里面所有的成员都是 public 权限的，那么这种特殊的抽象类就叫 接口 。
接口使用关键字 interface 来定义，并使用关键字 implements 来实现接口中的方法，且必须完全实现。
例子：
<?php
//定义接口
interface User{
function getDiscount();
function getUserType();
}
//VIP用户 接口实现
class VipUser implements User{
// VIP 用户折扣系数
private $discount = 0.8;
function getDiscount() {
return $this->discount;
}
function getUserType() {
return "VIP用户";
}
}
class Goods{
var $price = 100;
var $vc;
//定义 User 接口类型参数，这时并不知道是什么用户
function run(User $vc){
$this->vc = $vc;
$discount = $this->vc->getDiscount();
$usertype = $this->vc->getUserType();
echo $usertype."商品价格：".$this->price*$discount;
}
}
$display = new Goods();
$display ->run(new VipUser); //可以是更多其他用户类型
?>
运行该例子，输出：
VIP用户商品价格：80 元
该例子演示了一个 PHP 接口的简单应用。该例子中，User 接口实现用户的折扣，而在 VipUser 类里面实现了具体的折扣系数。最后商品类 Goods 根据 User 接口来实现不同的用户报价。
该例子仅限于演示 PHP 接口的用法，不涉及其科学与否。
实现多个接口
PHP也可以在继承一个类的时候同时实现多个接口：
class 子类 extends 父类 implemtns 接口1, 接口2, ...
{
......
}
抽象类和接口的区别
接口是特殊的抽象类，也可以看做是一个模型的规范。接口与抽象类大致区别如下：
一个子类如果 implements 一个接口，就必须实现接口中的所有方法（不管是否需要）；如果是继承一个抽象类，只需要实现需要的方法即可。
如果一个接口中定义的方法名改变了，那么所有实现此接口的子类需要同步更新方法名；而抽象类中如果方法名改变了，其子类对应的方法名将不受影响，只是变成了一个新的方法而已（相对老的方法实现）。
抽象类只能单继承，当一个子类需要实现的功能需要继承自多个父类时，就必须使用接口。
PHP 类的访问控制与封装 public,protected,private 修饰符
PHP 中通过在前面添加访问修饰符 public、protected 或 private 来实现对属性或方法的访问控制。
访问控制
类型的访问修饰符允许开发人员对类成员的访问进行控制，这是 OOP 语言的一个特性。
PHP 支持如下三种访问修饰符：
public (公有的)：类中的成员将没有访问限制，所有的外部成员都可以访问（读和写）这个类成员(包括成员属性和成员方法)。如果类的成员没有指定成员访问修饰符，将被视为 public 。
protected (受保护的)：被定义为 protected 的成员不能被该类的外部代码访问，但该类的子类具有访问权限。
private (私有的)：被定义为 private 的成员，允许同一个类里的所有成员访问，但对于该类的外部代码和子类都不允许访问。
修饰符访问权限对照表： public protected private
同一个类中 √ √ √
类的子类中 √ √
所有的外部成员 √
提示
在子类覆盖父类的方法时，子类中方法的访问权限不能低于父类被覆盖方法的访问权限。
封装
封装，就是把类（对象）的属性和服务结合成一个独立的单位，并尽可能隐藏内部的细节，只保留必要的接口与外部发生联系。这种封装特性，有效的保证了对象的独立性，使软件错误能够局部化，大大减少查错和排错的难度。
使用 private 关键字来对属性和方法进行封装：
<?php
class Person {
//将成员属性定义为 private
private $name;
private $age;
//定义一个构造方法初始化赋值
function __construct($name, $age) {
$this->name=$name;
$this->age=$age;
}
function say() {
echo "我的名字叫：".$this->name."<br />";
echo "我的年龄是：".$this->age;
}
}
$p1=new Person("张三", 20);
$p1->say();
?>
在该例子中，如果我们试图用 $p1->name = "张三"; 这种方式去访问对象属性就会产生错误。而构造方法和 say() 方法没有指定私有属性，在 PHP 中则默认为公有的（public）。
PHP 自动加载类 __autoload() 方法
__autoload() 方法用于自动加载类。
__autoload()
在实际项目中，不可能把所有的类都写在一个 PHP 文件中，当在一个 PHP 文件中需要调用另一个文件中声明的类时，就需要通过 include 把这个文件引入。不过有的时候，在文件众多的项目中，要一一将所需类的文件都 include 进来，一个很大的烦恼是不得不在每个类文件开头写一个长长的包含文件的列表。我们能不能在用到什么类的时候，再把这个类所在的 php 文件导入呢？
为此，PHP 提供了 __autoload() 方法，它会在试图使用尚未被定义的类时自动调用。通过调用此函数，脚本引擎在 PHP 出错失败前有了最后一个机会加载所需的类。
__autoload() 方法接收的一个参数，就是欲加载的类的类名，所以这时候需要类名与文件名对应，如 Person.php ，对应的类名就是 Pserson 。
例子：
Pserson.php
<?php
<?php
class Person {
private $name;
private $age;
function __construct($name, $age) {
$this->name = $name;
$this->age = $age;
}
function say() {
echo "我的名字叫：".$this->name."<br />";
echo " 我的年龄是：".$this->age;
}
}
?>
test.php
<?php
function __autoload($class_name)
{
require_once $class_name.'.php';
}
//当前页面 Pserson 类不存在则自动调用 __autoload() 方法，传入参数 Person
$p1 = new Person("张三","20");
$p1 -> say();
?>
运行 test.php ，输出：
我的名字叫：张三
我的年龄是：20
范围解析操作符（::）
范围解析操作符（::）
范围解析操作符（::）是一对冒号，可以用于访问静态成员、方法和常量，以及被覆盖类中的成员和方法。
当在类的外部使用 :: 符号访问这些静态成员、方法和常量时，必须使用类的名字，如下面例子所示。
:: 访问静态成员、方法例子
<?php
Class Person{
// 定义静态成员属性
public static $country = "中国";
// 定义静态成员方法
public static function myCountry() {
//内部访问静态成员属性
echo "我是".self::$country."人<br />";
}
}
// 输出静态成员属性值
echo Person::$country."<br />";
// 访问静态方法
Person::myCountry();
?>
使用 :: 符号访问静态成员及方法更多信息请参考《PHP 静态（static）》。
:: 访问父类覆盖的成员和方法的例子
class Person {
var $name;
var $sex;
var $age;
function say() {
echo "我的名字叫：".$this->name."<br />";
echo "性别：".$this->sex."<br />";
echo "我的年龄是：".$this->age;
}
}
class Student extends Person {
var $school;
function say() {
parent::say();
echo "我在".$this->school."上学";
}
}
关于类的方法覆盖与重载更多信息请参看《PHP 重载》
PHP 类的静态成员属性与静态方法 static 关键字
PHP 类中定义静态的成员属性和方法使用 static 关键字。
静态 static
声明类成员或方法为 static ，就可以不实例化类而直接访问，不能通过一个对象来访问其中的静态成员（静态方法除外）。静态成员属于类，不属于任何对象实例，但类的对象实例都能共享。
例子：
<?php
Class Person{
// 定义静态成员属性
public static $country = "中国";
// 定义静态成员方法
public static function myCountry() {
// 内部访问静态成员属性
echo "我是".self::$country."人<br />";
}
}
class Student extends Person {
function study() {
echo "我是". parent::$country."人<br />";
}
}
// 输出成员属性值
echo Person::$country."<br />"; // 输出：中国
$p1 = new Person();
//echo $p1->country; // 错误写法
// 访问静态成员方法
Person::myCountry(); // 输出：我是中国人
// 静态方法也可通过对象访问：
$p1->myCountry();
// 子类中输出成员属性值
echo Student::$country."<br />"; // 输出：中国
$t1 = new Student();
$t1->study(); // 输出：我是中国人
?>
运行该例子，输出：
中国
我是中国人
我是中国人
中国
我是中国人
小结
在类内部访问静态成员属性或者方法，使用 self::（注意不是 $slef），如：
slef:: $country
slef:: myCountry()
在子类访问父类静态成员属性或方法，使用 parent::（注意不是 $parent），如：
parent:: $country
parent:: myCountry()
外部访问静态成员属性和方法为 类名/子类名:: ，如：
Person::$country
Person::myCountry()
Student::$country
但静态方法也可以通过普通对象的方式访问。
PHP 常量（const）
常量 const
在类里面定义常量用 const 关键字，而不是通常的 define() 函数。
语法：
const constant = "value";
例子：
<?php
Class Person{
// 定义常量
const country = "中国";
public function myCountry() {
//内部访问常量
echo "我是".self::country."人<br />";
}
}
// 输出常量
echo Person::country."<br />";
// 访问方法
$p1 = new Person();
$p1 -> myCountry();
?>
运行该例子输出：
中国
我是中国人
常量的值一旦被定义后就不可在程序中更改。
参考阅读
《PHP 常量》
《范围解析操作符（::）》
《PHP 静态（static）》
PHP 特殊方法 __set()、__get()、__isset() 与 __unset()
__set() 方法用于设置私有属性值。
__get() 方法用于获取私有属性值。
__isset() 方法用于检测私有属性值是否被设定。
__unset() 方法用于删除私有属性。
实际应用中，经常会把类的属性设置为私有（private），那么需要对属性进行访问时，就会变得麻烦。虽然可以将对属性的访问写成一个方法来实现，但 PHP 提供了一些特殊方法来方便此类操作。
__set()
__set() 方法用于设置私有属性值：
function __set($property_name, $value)
{
$this->$property_name = $value;
}
在类里面使用了 __set() 方法后，当使用 $p1->name = "张三"; 这样的方式去设置对象私有属性的值时，就会自动调用 __set() 方法来设置私有属性的值。
__get()
__get() 方法用于获取私有属性值：
function __set($property_name, $value)
{
return isset($this->$property_name) ? $this->$property_name : null;
}
例子：
<?php
class Person {
private $name;
private $sex;
private $age;
//__set()方法用来设置私有属性
function __set($property_name, $value) {
echo "在直接设置私有属性值的时候，自动调用了这个 __set() 方法为私有属性赋值<br />";
$this->$property_name = $value;
}
//__get()方法用来获取私有属性
function __get($property_name) {
echo "在直接获取私有属性值的时候，自动调用了这个 __get() 方法<br />";
return isset($this->$property_name) ? $this->$property_name : null;
}
}
$p1=new Person();
//直接为私有属性赋值的操作， 会自动调用 __set() 方法进行赋值
$p1->name = "张三";
//直接获取私有属性的值， 会自动调用 __get() 方法，返回成员属性的值
echo "我的名字叫：".$p1->name;
?>
运行该例子，输出：
在直接设置私有属性值的时候，自动调用了这个 __set() 方法为私有属性赋值
在直接获取私有属性值的时候，自动调用了这个 __get() 方法
我的名字叫：张三
__isset()
__isset() 方法用于检测私有属性值是否被设定。
如果对象里面成员是公有的，可以直接使用 isset() 函数。如果是私有的成员属性，那就需要在类里面加上一个 __isset() 方法：
private function __isset($property_name)
{
return isset($this->$property_name);
}
这样当在类外部使用 isset() 函数来测定对象里面的私有成员是否被设定时，就会自动调用 __isset() 方法来检测。
__unset()
__unset() 方法用于删除私有属性。
同 isset() 函数一样，unset() 函数只能删除对象的公有成员属性，当要删除对象内部的私有成员属性时，需要使用__unset() 方法：
private function __unset($property_name)
{
unset($this->$property_name);
}
PHP 重载
PHP 重载
一个类中的方法与另一个方法同名，但是参数不同，这种方法称之为重载方法。
很遗憾因为 PHP 是弱类型的语言， 所以在方法的参数中本身就可以接收不同类型的数据，又因为 PHP 的方法可以接收不定个数的参数，所以在 PHP 里面没有严格意义上的方法重载。
PHP 中的重载是指在子类里面定义了一个和父类同名的方法，且该方法将在子类中将把父类的方法覆盖。
在子类中，因为从父类继承过来的方法可能无法访问子类定义的属性或方法，所以有时候重载是必要的。
例子：
<?php
class Person {
var $name;
var $age;
function say() {
echo "我的名字叫：".$this->name."<br />";
echo "我的年龄是：".$this->age;
}
}
// 类的继承
class Student extends Person {
var $school; //学生所在学校的属性
function say() {
echo "我的名字叫：".$this->name."<br />";
echo "我的年龄是：".$this->age."<br />";
echo "我正在".$this->school."学习";
}
}
$t1 = new Student();
$t1->name = "张三";
$t1->age = "18";
$t1->school = "人民大学";
$t1->say();
?>
运行该例子，输出：
我的名子叫：张三
我的年龄是：18
我正在人民大学学习
提示
如果父类定义方法时使用了 final 关键字，则不允许被子类方法覆盖。
访问父类被覆盖的方法
可以通过 :: 符号来访问父类被覆盖的方法或成员属性：
function say() {
parent::say();
//或者
Person::say();
echo "我在".$this->school."上学<br />";
}
范围解析操作符 :: 用法参见《PHP 范围解析操作符 ::》。
PHP 重载方法 __call()
__call() 方法用于监视错误的方法调用。
__call()（Method overloading）
为了避免当调用的方法不存在时产生错误，可以使用 __call() 方法来避免。该方法在调用的方法不存在时会自动调用，程序仍会继续执行下去。
语法：
function __call(string $function_name, array $arguments)
{
......
}
该方法有两个参数，第一个参数 $function_name 会自动接收不存在的方法名，第二个 $args 则以数组的方式接收不存在方法的多个参数。
在类里面加入：
function __call($function_name, $args)
{
echo "你所调用的函数：$function_name(参数：<br />";
var_dump($args);
echo ")不存在！";
}
当调用一个不存在的方法时（如 test() 方法）：
$p1=new Person();
$p1->test(2,"test");
输出的结果如下：
你所调用的函数：test(参数：
array(2) {
[0]=>int(2)
[1]=>string(4) "test"
}
)不存在！
PHP 抽象方法与抽象类 abstract 关键字
abstract 关键字用于定义抽象方法与抽象类。
抽象方法
抽象方法指没有方法体的方法，具体就是在方法声明的时候没有 {} 括弧以及其中的内容，而是直接在声明时在方法名后加上分号结束。
abstract 关键字用于定义抽象方法，语法：
abstract function function_name();
抽象类
只要一个类里面有一个方法是抽象方法，那么这个类就要定义为抽象类。抽象类同样用 abstract 关键字来定义。
抽象类不能产生实例对象，通常是将抽象方法做为子类方法重载的模板使用的，且要把继承的抽象类里的方法都实现。实际上抽象类是方便继承而引入的。
例子：
<?php
abstract class AbstractClass{
// 定义抽象方法
abstract protected function getValue();
// 普通方法
public function printOut(){
print $this->getValue()."<br />";
}
}
class ConcreteClass extends AbstractClass{
protected function getValue(){
return "抽象方法的实现";
}
}
$class1 = new ConcreteClass;
$class1->printOut();
?>
在这个例子中，父类定义了抽象方法以及对于方法的实现，但实际的内容却在子类里定义。
PHP 对象克隆 clone 关键字与 __clone() 方法
clone 关键字用于克隆一个完全一样的对象，__clone() 方法来重写原本的属性和方法。
对象克隆
有的时候我们需要在一个项目里面使用两个或多个一样的对象，如果使用 new 关键字重新创建对象，再赋值上相同的属性，这样做比较烦琐而且也容易出错。PHP 提供了对象克隆功能，可以根据一个对象完全克隆出一个一模一样的对象，而且克隆以后，两个对象互不干扰。
使用关键字 clone 来克隆对象。语法：
$object2 = clone $object;
例子：
<?php
class Person {
private $name;
private $age;
function __construct($name, $age) {
$this->name=$name;
$this->age=$age;
}
function say() {
echo "我的名字叫：".$this->name."<br />";
echo "我的年龄是：".$this->age;
}
}
$p1 = new Person("张三", 20);
$p2 = clone $p1;
$p2->say();
?>
运行例子，输出：
我的名字叫：张三
我的年龄是：20
__clone()
如果想在克隆后改变原对象的内容，需要在类中添加一个特殊的 __clone() 方法来重写原本的属性和方法。__clone() 方法只会在对象被克隆的时候自动调用。
例子：
<?php
class Person {
private $name;
private $age;
function __construct($name, $age) {
$this->name = $name;
$this->age = $age;
}
function say() {
echo "我的名字叫：".$this->name;
echo " 我的年龄是：".$this->age."<br />";
}
function __clone() {
$this->name = "我是假的".$this->name;
$this->age = 30;
}
}
$p1 = new Person("张三", 20);
$p1->say();
$p2 = clone $p1;
$p2->say();
?>
运行例子，输出：
我的名字叫：张三 我的年龄是：20
我的名字叫：我是假的张三 我的年龄是：30
PHP 对象的存储与传输（序列化 serialize 对象）
对象的存储与传输
在实际项目应用中，有些任务在一两个页面是无法完成的，由于变量到脚本执行完毕就释放，我们本页所生成的对象想在其它页面使用时便碰到了麻烦。
如果需要将对象及其方法传递到我们想使用对象的页面，比较简单可行的办法是将对象序列化后存储起来或直接传输给需要的页面，另一种办法是将对象注册为 session 变量。
序列化对象
对象序列化，就是将对象转换成可以存储的字节流。当我们需要把一个对象在网络中传输时或者要把对象写入文件或是数据库时，就需要将对象进行序列化。
序列化完整过程包括两个步骤：一个是序列化，就是把对象转化为二进制的字符串，serialize() 函数用于序列化一个对象；另一个是反序列化，就是把对象被序列转化的二进制字符串再转化为对象，unserialize() 函数来反序列化一个被序列化的对象。这样整个过程下来，对象内的类型结构及数据都是完整的。
语法：
string serialize( mixed value )
mixed unserialize( string str [, string callback] )
例子：
<?php
class Person {
private $name;
private $age;
function __construct($name, $age) {
$this->name = $name;
$this->age = $age;
}
function say() {
echo "我的名字叫：".$this->name."<br />";
echo " 我的年龄是：".$this->age;
}
}
$p1 = new Person("张三", 20);
$p1_string = serialize($p1);
//将对象序列化后写入文件
$fh = fopen("p1.text", "w");
fwrite($fh, $p1_string);
fclose($fh);
?>
打开 p1.text 文件，里面写入的内容如下：
O:6:"Person":2:{s:12:" Person name";s:4:"张三";s:11:" Person age";i:20;}
但通常不去直接解析上述序列化生成的字符。
反序列化：
<?php
class Person {
private $name;
private $age;
function __construct($name, $age) {
$this->name = $name;
$this->age = $age;
}
function say() {
echo "我的名字叫：".$this->name."<br />";
echo " 我的年龄是：".$this->age;
}
}
$p2 = unserialize(file_get_contents("p1.text"));
$p2 -> say();
?>
运行该例子，输出：
我的名字叫：张三
我的年龄是：20
提示
由于序列化对象不能序列化其方法，所以在 unserialize 的时候，当前文件必须包含对应的类或者 require 对应的类文件。
序列化只能用于有限用户的情况下，因为需要为每个用户单独存储或写入文件，且保证文件名不能重复。在用户不能正常退出浏览器的情况下，不能保证文件被删除。
对象注册为 session 变量
当用户数量很多时,可以考虑用 session 来保存对象。关于 session 的更多信息，请参见《PHP Session》。
例子：
<?php
session_start();
class Person {
private $name;
private $age;
function __construct($name, $age) {
$this->name = $name;
$this->age = $age;
}
function say() {
echo "我的名字叫：".$this->name."<br />";
echo " 我的年龄是：".$this->age;
}
}
$_SESSION["p1"] = new Person("张三", 20);
?>
读取 session ：
<?php
session_start();
class Person {
private $name;
private $age;
function __construct($name, $age) {
$this->name = $name;
$this->age = $age;
}
function say() {
echo "我的名字叫：".$this->name."<br />";
echo " 我的年龄是：".$this->age;
}
}
$_SESSION["p1"] -> say();
?>
运行该例子，输出：
我的名字叫：张三
我的年龄是：20
与序列化一样，注册对象为 session 变量时并不能保存其方法，所以在读取 session 变量的时候，当前文件必须包含对应的类或者 require 对应的类文件。