第18章 PHP类与对象
PHP对面向对象功能的支持使PHP在大型项目开发中应用成为可能，面向对象编程可提高程序的重复利用率，大大提高编辑效率。本章将带读者走进PHP面向对象的神奇世界，见识PHP的面向对象给编程带来的方便、高效、易于管理之处。
18.1 类与对象的初探
“这个世界是由什么组成的？”这个问题如果让不同的人来回答会得到不同的答案。如果是一个化学家，他也许会告诉你“还用问嘛？这个世界是由分子、原子、离子等的物质组成的”。如果是一个画家呢？他也许会告诉你，“这个世界是由不同的颜色所组成的”……从不同的角度看问题，会得到不同答案！但如果让一个分类学家来考虑问题就有趣得多了，他会告诉你“这个世界是由不同类型的物与事所构成的”好！作为面向对象的程序员来说，就是要站在分类学家的角度去考虑问题！是的，这个世界是由动物、植物等组成的。动物又分为单细胞动物、多细胞动物、哺乳动物等，哺乳动物又分为人、大象、老虎……
接下来取与自身关系最近的人类来讲解。首先来看看人类所具有的一些特征，这个特征包括属性（一些参数，数值）及方法。每个人都有身高、体重、年龄、血型等一些属性。人会劳动、人都会直立行走、人都会用自己的头脑去创造工具等这些方法！人之所以能区别于其他类型的动物，是因为每个人都具有人这个群体的属性与方法。“人类”只是一个抽象的概念，它仅仅是一个概念，它是不存在的实体！但是所有具备“人类”这个群体的属性与方法的对象都叫人！这个对象“人”是实际存在的实体！每个人都是人这个群体的一个对象。老虎为什么不是人？因为它不具备人这个群体的属性与方法，老虎不会直立行走，不会使用工具等！所以说老虎不是人！
理解类和对象最简单的方法可能就是创建一些类和对象。
18.2 第一个类
理解类和对象最简单的方法可能就是创建一些类和对象，那么本节就使用PHP来创建一个“人类”。每个类的定义都以关键字class开头，后面跟着类名，可以是任何非PHP保留字的名字。后面跟着一对大括号，里面包含有类成员和方法的定义。创建一个最简单的类的代码，如下所示：
class People //创建类
{
}
注意 类名可以是包含字母、数字和下画线字符的任何组合，但不能以数字开头。
上例中的Dictionary类尽管用处有限，但完全合法。那么如何使用该类来创建一个对象呢？要创建一个对象的实例，必须创建一个新对象并将其赋给一个变量。当创建新对象时该对象总是被赋值，除非该对象定义了构造函数并且在出错时抛出了一个异常。
$people = new People(); //实例化
这就告诉PHP引擎来实例化一个新对象。然后，返回的对象可以存储在一个变量中以供将来使用。
18.3 属性
在类的主体中，可以声明叫做属性的特殊变量。对属性或方法的访问控制，是通过在前面添加关键字public、protected或private来实现的，具体的访问形式将在后面小节中介绍。
但现在例子中将所有属性声明为public。下面的代码显示了一个声明了两个属性的类：
class People //创建类
{
public $name = ‘张三’; //名字
public $age = ‘18’; //年龄
}
正如所看到的，可以在声明属性的同时为其赋值。可以用print_r()函数快速浏览一下对象的状态。代码18-1显示People对象现在具有哪些成员，如下所示。
代码18-1 People对象一览
<span class="kindle-cn-bold">People对象一览</span><hr />
<?php
class People //创建类
{
public $name = '张三'; //名字
public $age = 18; //年龄
}
$people = new People(); //实例化一个People对象
echo '≶pre>'; //按照原格式输出
print_r($people); //输出$people对象
echo '</pre>';
?>
如果运行该脚本，将看到如图18.1所示的效果。
图18.1 People对象一览
可以使用对象操作符“->”访问公共对象属性。所以“$people-> name”表示由$people引用的People对象的$name属性。如果可以访问属性，就意味着可以设置和获得其值。代码18-2中的代码创建People类的两个实例，换言之，它实例化两个People对象并更改对象的$name和$age属性。
代码18-2 创建People类的两个实例
<span class="kindle-cn-bold">创建People类的两个实例</span><hr />
<?php
class People //创建类
{
public $name = '张三'; //名字
public $age = 18; //年龄
}
$people1 = new People(); //实例化一个People1对象
$people2 = new People(); //实例化一个People2对象
$people1->name = '小乔'; //赋值people1的名字
$people1->age = 26; //赋值people1的年龄
$people2->name = '张飞'; //赋值people2的名字
$people2->age = 30; //赋值people2的年龄
echo '<pre>'; //按照原格式输出
print_r($people1); //输出$people1对象
print_r($people2); //输出$people2对象
echo '</pre>';
?>
在代码的第9、10两行，分别创建两个People类的对象。此后，使用对象操作符“->”对各自的名字和年龄属性进行赋值。运行以上代码，可以看到这两个对象的属性值，如图18.2所示。
图18.2 People类的两个实例
18.4 方法
虽然用对象存储数据有优点，但是现在可能还没有感觉到。对象可以是东西，但关键在于它们还可以做事情。本节就来重点介绍类的方法。
简单地说，方法是在类中声明的函数。它们通常（但不总是）通过对象实例使用对象操作符来调用的。代码18-3演示了向People类中添加一个方法，并调用该方法。
代码18-3 向People类中添加方法
<span class="kindle-cn-bold">向People类中添加方法</span><hr />
<?php
class People //创建类
{
public $name = '张三'; //名字
public $age = 18; //年龄
function intro() //添加方法
{
return "我的名字叫{$this->name}，今年{$this->age}。\r\n";
}
}
$people = new People(); //实例化一个People对象
echo '<pre>'; //按照原格式输出
print_r($people->intro()); //输出$people对象
echo '</pre>';
?>
正如所看到的，声明intro()方法与声明任何函数的方式一样，只不过它是在类中声明。intro()方法是通过People实例使用对象操作符调用的。intro()函数访问属性来提供对象状态的简述。
$this伪变量提供了一种用于对象引用自己的属性和方法的机制。在对象外部，可以使用句柄来访问它的元素（在本例子中是$ people）。在对象内部，则无此句柄，所以必须求助于$this。
以上代码的第7～11行就是新添加的类方法，该方法的名称为intro，返回一个人的姓名和年龄的信息。其中姓名和年龄是通过对象操作符“->”访问对象属性而得到的。运行后得到的结果如图18.3所示。
图18.3 向People类中添加方法
18.5 构造函数
在本章的18.3节中，是通过实例化对象后再对它的属性进行操作。是否可以在实例化的时候就为这些属性赋值呢？答案是肯定的，本节就来介绍类的一个特别方法——构造函数。
PHP引擎识别许多“魔术”方法。如果定义了方法，则PHP引擎将在相应的情况发生时自动调用这些方法。最常实现的方法是构造函数方法。PHP引擎在实例化对象时调用构造函数。对象的所有基本设置代码都放在构造函数中。在PHP V4中，通过声明与类同名的方法来创建构造函数。在PHP V5中，应声明叫做__construct()的方法。代码18-4显示People类的构造函数。
代码18-4 People类的构造函数
<span class="kindle-cn-bold">People类的构造函数</span><hr />
<?php
class People //创建类
{
public $name = ''; //名字
public $age = 0; //年龄
function __construct($name, $age) //构造函数
{
$this->name = $name; //赋值名字
$this->age = $age; //赋值年龄
}
function intro() //添加方法
{
return "我的名字叫{$this->name}，今年{$this->age}岁。\r\n";
}
}
$people = new People('和氏璧', 29); //实例化一个People对象
echo '<pre>'; //按照原格式输出
print_r($people->intro()); //输出$people对象
echo '</pre>';
?>
从以上代码可见，构造函数的添加与添加任何类方法的方式一样，只不过它的函数名一定要为“__construct”。第18行的代码是实例化一个People类的对象，其中有带入构造函数所需的两个参数。
现在的People类比以前更安全。所有People对象都已经用必需的参数初始化过了。当然，还无法阻止一些人随后更改$name属性或将$age设置为空。可喜的是，PHP V5可以帮助您实现这一功能。
代码运行后，得到的结果如图18.4所示。
图18.4 使用People类的构造函数
18.6 关键字：在此我们是否可以有一点隐私
前面已经看到与属性声明相关的public关键字。该关键字表示属性的可见度。事实上，属性的可见度可以设置为public、private和protected。声明为public的属性可以在类外部写入和读取，声明为private的属性只在对象或类上下文中可见。声明为protected的属性只能在当前类及其子类的上下文中可见。
如果将属性声明为private并试图从类范围外部访问它（如代码18-5所示），PHP引擎将抛出致命错误。
代码18-5 试图从类范围外部访问属性
<span class="kindle-cn-bold">试图从类范围外部访问属性</span><hr />
<?php
class People //创建类
{
private $name = ''; //名字
private $age = 0; //年龄
function __construct($name, $age) //构造函数
{
$this->name = $name; //赋值名字
$this->age = $age; //赋值年龄
}
function intro() //添加方法
{
return "我的名字叫{$this->name}，今年{$this->age}岁。\r\n";
}
}
$people = new People('和氏璧', 29); //实例化一个People对象
echo '<pre>'; //按照原格式输出
print_r($people->name); //输出$people对象
echo '</pre>';
?>
在代码的第5~6行，设置名字与年龄的关键字都为private。然后创建完一个People类的对象之后，试图通过对象操作符“->”直接读取其name属性，这时PHP便会抛出一个致命错误，如图18.5所示。
图18.5 试图从类范围外部访问属性
一般来说，应该将大多数属性都声明为private，然后根据需要提供获得和设置这些属性的方法。这样就可以控制类的接口，使一些数据只读，在将参数分配给属性之前对参数进行清理或过滤，并提供与对象交互的一套明确的规则。
修改方法可见度的方法与修改属性可见度的方法一样，即在方法声明中添加public、private或protected。如果类需要使用一些外部世界无须知道的家务管理方法，则可以将其声明为private。在代码18-6中，get_name()方法为People类的用户提供了获取名字的接口。该类还需要相应年龄的查询，不过年龄对于女性来说是秘密，所以这里声明为private方法。
代码18-6 为People类开发查询接口
<span class="kindle-cn-bold">为People类开发查询接口</span><hr />
<?php
class People //创建类
{
private $name = ''; //名字
private $age = 0; //年龄
function __construct($name, $age) //构造函数
{
$this->name = $name; //赋值名字
$this->age = $age; //赋值年龄
}
function intro() //添加方法
{
return "我的名字叫{$this->name}，今年{$this->age}岁。\r\n";
}
function get_name() //添加方法
{
return $this->name; //返回名字
}
private function get_age() //添加方法
{
return $this->age; //返回年龄
}
}
$people = new People('和氏璧', 29); //实例化一个People对象
echo '<pre>'; //按照原格式输出
print_r($people->get_name()); //输出名字
echo '</pre>';
?>
将get_age()方法声明为private，能防止该类不适当地调用get_age()。与属性一样，尝试从包含类外部调用私有方法将导致致命错误。代码运行后，得到的结果如图18.6所示。
图18.6 为People类开发查询接口
可见对象的名字被正确地读取出来，而且没有报错。
18.7 在类上下文操作
到目前为止，所看到的方法和属性都在对象上下文中进行操作。也就是说，必须使用对象实例，通过$this伪变量或标准变量中存储的对象引用来访问方法和属性。有时候，可能发现通过类而不是对象实例来访问属性和方法更有用。这种类成员叫做静态成员。
要声明静态属性，将关键字static放在可见度修饰符后面，直接位于属性变量前面。下面的代码显示了单个静态属性：$number，存放用于保存和读取People数据的默认目录的路径。因为该数据对于所有对象是相同的，所以将它用于所有实例都是有意义的。
class People {
public static $number = 0;
//...
}
可以使用范围解析操作符来访问静态属性，该操作符由双冒号“::”组成。范围解析操作符应位于类名和希望访问的静态属性之间。
People::$ number = 10;
正如所看到的，访问该属性无需实例化People对象。声明和访问静态方法的语法与此相似。再次，应将static关键字放在可见度修饰符后。代码18-7显示了一个静态方法，它们访问声明为private的$number属性。
代码18-7 访问$number属性的静态方法
<span class="kindle-cn-bold">访问$number属性的静态方法</span><hr />
<?php
class People //创建类
{
private static $number = 10; //private的静态变量
public static function get_number() //public的静态方法
{
return self::$number; //返回number数值
}
}
echo '<pre>'; //按照原格式输出
print_r(People::get_number()); //调用类的静态方法
echo '</pre>';
?>
由以上代码可看出，用户不再能访问$number属性了。通过创建特殊方法来访问属性，可以确保所提供的任何值是健全的。这个方法使用关键字self和访问解析操作符来引用$number属性。不能在静态方法中使用$this，因为$this是对当前对象实例的引用，但静态方法是通过类而不是通过对象调用的。如果PHP引擎在静态方法中看到$this，它将抛出致命错误和一条提示消息。
代码运行后得到的结果如图18.7所示。
图18.7 访问$number属性的静态方法
需要使用静态方法有两个重要原因。首先，实用程序操作可能不需要对象实例来做它的工作。通过声明为静态，为客户机代码节省了创建对象的工作量。第二，静态方法是全局可用的。这意味着可以设置一个所有对象实例都可以访问的值，而且使得静态方法成为共享系统上关键数据的好办法。
尽管静态属性通常被声明为private来防止他人干预，但有一种方法可以创建只读静态范围的属性，即声明常量。与全局属性一样，类常量一旦定义就不可更改。它用于状态标识和进程生命周期中不发生更改的其他东西，比如所处的共同环境。
可以用const关键字声明类常量。例如，因为People对象的实际实现都设定有一个身高极限。如下将其设置为类常量。
class People {
const MAXLENGTH = 250;
// …
}
类常量始终为public，所以不能使用可见度关键字。这并不是问题，因为任何更改其值的尝试都将导致解析错误。还要注意，与常规属性不同，类常量不以美元符号开始。
18.8 继承
继承是面向对象最重要的特点之一，就是可以实现对类的复用。通过“继承”一个现有的类，可以使用已经定义的类中的方法和属性。继承而产生的类叫做子类。□被继承的类，叫做父类，也被称为超类。PHP是单继承的，一个类只可以继承一个父类，但一个父类却可以被多个子类所继承。从子类的角度看，它“继承（inherit，extends）”自父类；而从父类的角度看，它“派生（derive）”子类。它们指的都是同一个动作，只是角度不同而已。子类不能继承父类的私有属性和私有方法。
说明 在PHP中类的方法可以被继承，类的构造函数也能被继承。
使用extends关键字创建子类。如下是Student类的最小实现：
class Student extends People
{
}
Student类现在的功能与People类完全相同。因为它从People继承了所有的公共（和保护）属性，所以可以将应用于People对象的相同操作应用于Student对象。这种关系可以扩展到对象类型。使用Student类实例化后的对象显然是Student类的实例，但它也是People的实例。同样地，以一般化的顺序来讲，一个人同时是人类、哺乳动物和动物。可以使用instanceof操作符来测试这一点，如果对象是指定类的成员，则返回true，如代码18-8所示。
代码18-8 使用instanceof操作符测试继承
<span class="kindle-cn-bold">使用instanceof 操作符测试继承</span><hr />
<?php
class People //创建类
{
public $name = ''; //名字
public $age = 0; //年龄
function __construct($name, $age) //构造函数
{
$this->name = $name; //赋值名字
$this->age = $age; //赋值年龄
}
function intro() //添加方法
{
return "我的名字叫{$this->name}，今年{$this->age}岁。\r\n";
}
function get_name() //添加方法
{
return $this->name; //返回名字
}
function get_age() //添加方法
{
return $this->age; //返回年龄
}
}
class Student extends People //类的继承
{
}
echo '<pre>'; //安装原格式输出
$student = new Student('旺福', 21); //实例化Student对象
if ($student instanceof Student) { //判断是否是Student类的实例
print "该对象是Student类的实例\r\n"; //输出
}
if ($student instanceof People) { //判断是否是People类的实例
print "该对象是People类的实例\r\n"; //输出
}
echo '</pre>';
?>
以上代码首先声明一个People类，并在代码的第26~28行创建Student类来继承People类。第31行是实例化一个Student对象，发现它与实例化People类时一样都需要传入初始参数。因为它是继承了People类，所以同样也继承了构造函数。之后使用instanceof关键字来判断这个对象是否是Student类和People类的实例。运行后得到的结果如图18.8所示。
图18.8 使用instanceof操作符测试继承
以上是继承父类的一个例子，它只是简单地继承了父类能被继承的所有属性和方法。但是学生是有区别于人类这个大的范围定义的，所以在继承父类之后还需要给它添加一些特有的属性和方法。代码18-9展示了为新的Student类添加年级和班主任属性，以及一个能计算简单加法的方法，如下所示。
代码18-9 添加了属性和方法的Student实现
<span class="kindle-cn-bold">添加了属性和方法的Student实现</span><hr />
<?php
class People //创建类
{
public $name = ''; //名字
public $age = 0; //年龄
function __construct($name, $age) //构造函数
{
$this->name = $name; //赋值名字
$this->age = $age; //赋值年龄
}
function intro() //添加方法
{
return "我的名字叫{$this->name}，今年{$this->age}岁。\r\n";
}
function get_name() //添加方法
{
return $this->name; //返回名字
}
function get_age() //添加方法
{
return $this->age; //返回年龄
}
}
class Student extends People //类的继承
{
private $grade = '一年级'; //年级
private $head_teacher = '张三'; //班主任
function add($a, $b) //加法函数
{
return $a + $b;
}
}
echo '<pre>'; //安装原格式输出
$student = new Student('旺福', 21); //实例化Student对象
echo $student->intro(); //自我介绍
echo "12 + 9 = ".$student->add(12, 9); //加法运算
echo '</pre>';
?>
以上代码的第26~34行创建了一个继承自People的Student类，并为这个类添加$grade、$head_teacher属性及add()方法。第37行是实例化这个Student类，之后调用继承自父类的intro()方法进行自我介绍。最后再调用自身的add()方法做了一个加法运算。运行后得到的结果如图18.9所示。
图18.9 添加了属性和方法的Student实现
18.9 典型实例
【实例18-1】本实例演示如何动态调用类。
实现动态调用类，其原理和可变变量，以及变量函数有共同之处。都是根据用户或系统提供的数据，来运行相对应的变量、函数或类。
在实际应用中，一个项目中的类可以有若干个，而且每一个类的功能也不相同。为了方便，通常把相同功能函数都存放在同一个类中，例如：一个名为“upload”的类，其包含的应该是与上传有关的函数。
为了能够根据用户或系统提供的数据来动态调用类，需要对类及其内部函数进行统一的定义。下面通过代码来介绍动态调用类的方法。
定义默认情况下调用的类，代码如下所示。
代码18-10 动态调用类的方法
<?php
//定义一个与文件中相同的类
class showtable{
//创建构造函数，用于初始化类
function showuser(){}
//创建主函数，默认运行此函数
function main(){
echo "<table border='1'><tr><td>显示表格</td></tr></table>";
}
//创建其他函数
function other(){
echo "这是showtable类中函数other()";
}
}
?>
定义根据用户输入调用的类，代码如下所示。
代码18-11 定义根据用户输入调用的类
<?php
//创建一个与文件中相同的类
class showuser{
//创建构造函数
function showuser(){}
//创建默认函数
function main($option){
$u = explode(",",$option);
echo "用户姓名：".$u[0]."，年龄：".$u[1];
}
}
?>
接着定义主文件，用于动态调用其他类，代码如下所示。
代码18-12 定义主文件
<?php
//检查客户端提交的数据，确定是否需要调用其他类处理数据
if(isset($_POST["c"])){
//根据客户端数据，确定要调用的类
$c = $_POST["c"];
}else{
//如果用户没有指定类，则默认调用showtable类
$c = "showtable";
}
//检测客户端是否指定了方法来处理数据
if(isset($_POST["a"])){
//根据客户端数据，调用指定的方法
$a = $_POST["a"];
}else{
//如果用户没有指定方法，则默认调用main()函数
$a = "main";
}
//检查客户端是否提交了其他数据
if(isset($_POST["d"])){
//如果客户端提交了其他数据，格式化数据
$d = implode(",",$_POST["d"]);
}else{
//如果客户端没有提交其他数据，设置为空
$d = "";
}
//检测类文件是否存在
if(file_exists($c.".php")){
//加载类文件
include($c.".php");
//检测类文件加载后，是否存在类
if(class_exists($c)){
//当类存在时，初始化类
$e = new $c();
//调用对象的方法
$e->$a($d);
}
}
?>
<form action="Ch18-1.php" method="post">
姓名：<input type="text" name="d[name]" value=""/><br/>
年龄：<input type="text" name="d[age]" value="" size="40" maxlength="40"/>
<br>
<input type="hidden" name="c" value="showuser"/>
<input type="submit" name="name" value="提交"/>
</form>
运行该程序后，运行结果如图18.10所示。
图18.10 程序运行结果
在表单中的姓名文本框中输入“小李”，年龄文本框中输入“17”，单击“提交”按钮，运行结果如图18.11所示。
图18.11 程序运行结果
【实例18-2】在PHP中关于对象的知识，最多的是与类有关。当使用“new”关键字把类实例化后，就产生了对象。实际上PHP也支持把其他类型变量转换为对象，这样做有时可以使某一类型的变量，操作起来更加简单，例如数组。
取得对象的有两种方法：
- 使用new关键字，对类进行实例化，得到与类有关的对象。
- 使用“（object）”把其他类型的变量，转换为对象类型，也可以得到与变量相关的对象。
代码18-13 把其他类型变量转换为对象
<?php
//定义一个字符串型变量
$str = "通过对象使用字符串";
//转换字符串类型为对象
$obj = (object)$str;
//使用新产生的对象
echo $obj->scalar;
echo "<br>";
$tree = array("name"=>"小明","age"=>17); //定义一个数组
$obj1 = (object)$tree; //定义一个函数
echo $obj1->name."今年".$obj1->age."岁";
?>
运行该程序后，运行结果如图18.12所示。
图18.12 程序运行结果
18.10 小结
由于篇幅有限，因此不可能全部介绍到PHP的所有知识，进一步研究有两个方向：广度和深度。广度指的是超出本文范围的那些特性，比如抽象类、接口、迭代器接口、反射、异常和对象复制。深度指的是设计问题。尽管理解PHP中可用于面向对象编程的工具范围很重要，但考虑如何最佳使用这些特性同样重要。如果读者感兴趣可以参考专门讲述面向对象上下文中设计模式的资料。
18.11 习题
一、填空题
1. 类是一组具有相同属性和行为的对象的抽象，是_____、_____的定义。
2. 面向对象的三大语言特点是：_____、_____、_____。
3. 关键字_____声明的字段可以被该类和该类的子类访问，关键字_____声明的字段可以被外部直接访问。
4. 一个_____只可以继承一个_____，但一个_____却可以被多个所继承，子类不能继承父类的_____和_____。
5. 如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的__________。
6. 调用父类的构造函数时，必须使用关键字__________调用。
7. 析构函数的作用是__________。
8. 在类中使用当前对象的属性和方法时，必须使用__________取值。
二、选择题
1. 使用哪个指令可以实例化类（ ）。
A. class
B. new
C. create
D. method
2. 继承性是面向对象程序设计语言的一个主要特点，表示继承关系的关键字是（ ）
A. class
B. new
C. extends
D. static
3. 下列哪个是构造函数名（ ）。
A. _destruct()
B. _construct()
C. 不确定
D. 以上都不是
4. final关键字修饰的类（ ）。
A. 可以被继承
B. 可以被覆盖
C. 既能被继承又能被覆盖
D. 既不能被继承又不能被覆盖
5. 下面程序的运行结果为（ ）
01 class student
02 {
03 function construct(){
04 echo “I am a student . <br>”;
05 }
06
07 function teacher() {
08 echo”I am a teacher . “;
09 }
10 }
11
12 $peo=new student();
A. I am a student
I am a teacher.
B. I am a student.
C. I am a teacher.
D. 无任何输出
三、简答题
1. 简述类和对象的定义。
2. 阐述限定字符public、private、protected、final、const、static的作用。
3. 解释构造函数和析构函数的差异。
四、编程题
1. 创建一个oblong类，编写一个方法计算长方形的周长。
2. 创建一个购物类，创建物品名称、价格，判断是否有足够的资金购买，如果买，输出物品名称及价格，如果不买输出原因。
在线客服
共有条评论 网友评论