PHP基础之面向对象

悠悠 2022-07-11 05:57 185阅读 0赞

# 面向对象编程 #

面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。OOP 达到了软件工程的三个主要目标：重用性、灵活性和扩展性。

面向对象一直是软件开发领域比较热门的话题。首先，面向对象比较符合人类看待事物的一般规律。其次，采用面向对象方法可以使系统的各部分各司其职、各尽所能。为编程人员敞开一扇大门，使其编程的代码更简洁、更易于维护，并且具有更强的重用性。但PHP并非是真正面向对象编程的语言，PHP是一个混合型的语言，你可以使用面向对象，也可以使用传统的过程化编程。

# 类和对象 #

类：类是对现实生活中一类具有共同特征的事务的抽象(设计图)，包括成员属性和成员方法两部分。

对象：对象是系统中用来描述客观事务(类)的一个实例化。

## 类的声明 ##

<?php
 
 
 class Person{
 
 var $name; //名称
 public $sex; //性别
 protected $age;//年龄
 
 //声明一个构造方法，在创建对象时为成员属性赋初值。
 function __construct($name = "无名",$sex = "保密",$age = 1){
 $this->name = $name;
 $this->sex = $sex;
 $this->age = $age;
 }
 
 function say(){
 echo $this->name."说";
 }
 
 function eat(){
 echo $this->name."吃";
 }
 
 //声明一个析构方法，在对象销毁前自动调用。
 function __destruct(){
 echo $this->name."去世";
 }
 }
 
 $p1 = new Person("张三","男",17);
 $p1->say();
 $p2 = new Person("李四","男",17);
 $p3 = new Person("王五","女",16);
 
 /*
 * 运行结果为：
 * 张三说
 * 王五去世
 * 李四去世
 * 张三去世
 */

在PHP中声明一个类使用class关键字，在类中声明成员属性时变量前一定要使用关键字，如：public，protected，private等关键字，经过关键字修饰的成员变量都有一定的意义。若不需要特定意义的修饰，就使用var关键字，一旦成员属性有其他的关键字修饰就需要去掉var。

权限修饰：public关键字，可以在类的内部外部自由访问，修改。

protected关键字，能够在类和类的子类中访问，修改。

private关键字，只允许在类中使用。

访问方式：访问对象中的成员要使用对象->成员，对象->方法的形式，如果对象中的成员不是静态的，那么这是唯一的访问形式。

特殊引用：特殊引用$this表示的是“本对象”的一个引用，使用$this可以访问自己对象内部的成员属性，只能在对象方法中使用。

构成方法：\_\_construct()方法会在每次使用new关键字实例化对象时自动调用，不能主动通过对象的引用调用构成方法。所以通常使用构造方法执行一些初始化操作。

析构方法：\_\_destruct()方法在对象被销毁前自动调用这个方法，并且析构方法不能带有任何参数。需要注意的是，对象的引用存放在栈内存中，由于栈的后进先出特点，后创建的对象先被销毁。

###    私有属性专用魔术方法 ###

一般来说，把类中的成员属性定义为private的，这样才更符合实际逻辑，才能对类中的成员属性起到保护作用。但在成员属性取值和赋值时都需要定义公用的方法，这样显得及频繁又烦琐，因此在PHP5中，提供\_\_get()和\_\_set()来对私有属性获取或赋值，以及提供\_\_isset()和\_\_unset()来检测和删除私有属性。

<?php
 
 
 class Person{
 
 private $name; //名称
 private $sex; //性别
 private $age;//年龄
 
 //声明一个构造方法，在创建对象时为成员属性赋初值。
 function __construct($name = "无名",$sex = "保密",$age = 1){
 $this->name = $name;
 $this->sex = $sex;
 $this->age = $age;
 }
 
 //在类的外部直接为成员属性赋值时，自动调用。
 function __set($name, $value){
 if($name == "age"){
 if($value > 28 || $value < 17){
 echo "年龄在17 - 26 之间";
 return;
 }
 }
 $this->$name = $value;
 }
 
 //在类的外部直接获取成员属性时，自动调用。
 function __get($name){
 if($name == "age"){
 return $this->$name + 2;
 }
 return $this->$name;
 }
 
 //在类的外部使用isset()方法测试成员属性时，自动调用。
 function __isset($name){
 return isset($this->$name);
 }
 
 //在类的外部使用unset()方法测试成员属性时，自动调用。
 function __unset($name){
 unset($this->$name);
 }
 
 function say(){
 echo $this->name."说";
 }
 
 function eat(){
 echo $this->name."吃";
 }
 
 //声明一个析构方法，在对象销毁前自动调用。
 function __destruct(){
 echo $this->name."去世";
 }
 }
 
 $p1 = new Person("张三","男",17);
 $p1->age = 14; //年龄在17 - 26 之间
 echo $p1->age; //19
 var_dump(isset($p1->mail)); //bool(false)

\_\_get()，\_\_set()，\_\_isset()，\_\_unset()这四个方法都是我们添加到类里面的，在需要时自动调用，来完成对象外部对对象内部私有属性的操作。需要注意的是：1、\_\_set()，\_\_get()是专门为类的私用属性(private，protected)设立的。对于public的属性，外部可以直接访问和设置 2、在PHP5.3以后\_\_get()，\_\_set()，\_\_isset()，\_\_unset()这四个方法只能是public类型的，且不可用static修饰，否则会报错。

### 常见关键字和魔术方法 ###

<table style="color:rgb(0,0,0); font-family:Arial; font-size:14px; line-height:26px"> 
 <thead> 
 <tr> 
 <td style="background:rgb(94,94,94)"> &nbsp;关键字&nbsp; </td> 
 <td style="background:rgb(94,94,94)"> 类 </td> 
 <td style="background:rgb(94,94,94)"> &nbsp;类方法&nbsp; </td> 
 <td style="background:rgb(94,94,94)"> &nbsp;类成员&nbsp; </td> 
 <td style="background:rgb(94,94,94)"> &nbsp;描述&nbsp; </td> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="background:rgb(238,238,238)"> final </td> 
 <td style="background:rgb(238,238,238)"> &nbsp;√ &nbsp; </td> 
 <td style="background:rgb(238,238,238)"> √&nbsp; </td> 
 <td style="background:rgb(238,238,238)"> X </td> 
 <td style="background:rgb(238,238,238)"> 加在类或类方法前，修饰类或方法不可被继承或覆盖，不可以修饰成员属性。 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(238,238,238)"> static </td> 
 <td style="background:rgb(238,238,238)"> &nbsp;X &nbsp; </td> 
 <td style="background:rgb(238,238,238)"> √&nbsp; </td> 
 <td style="background:rgb(238,238,238)"> √ </td> 
 <td style="background:rgb(238,238,238)"> 修饰类方法或成员属性为静态，static修饰的类方法和成员属性在多个对象之 间共享，且可以使用类名直接访问：类名::静态成员属性，类名::静态方法()。 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(238,238,238)"> const </td> 
 <td style="background:rgb(238,238,238)"> &nbsp; &nbsp; </td> 
 <td style="background:rgb(238,238,238)"> &nbsp; </td> 
 <td style="background:rgb(238,238,238)"> √ </td> 
 <td style="background:rgb(238,238,238)"> 将类中的成员属性定义为常量，在声明常量时不要使用‘$’符号，并且一定要 赋初值，后期没有办法为常量赋值。 </td> 
 </tr> 
 </tbody> 
</table>

魔术方法：\_\_clone()魔术方法会在使用clone关键字克隆一个对象时被调用，在该方法中自动包含$this和$that两个对象的引用，$this是副本对象的引用，而$that则是原来对象的引用。

\_\_toString()是快速获取对象的字符串表示的最便捷的方式，它是在直接输出对象引用时自动调用。

\_\_clal()方法在调用对象中不存在的方法时会自动调用该方法，该方法需要两个参数：第一个参数接受不存在的方法名，第二个参数是以数组形式存放的参数列表。

\_\_autoload()方法提供了类的自动加载功能，它是全局函数，不是在类中声明。

serialize()函数和unserialize()函数配合在一起使用，serialize()函数就是将PHP中的变量(数组，对象)等等的值序列化为字符串后存储起来，这样比较有利于存储和传递PHP的值，同时不丢失其类型和结构。unserialize()函数可以将已序列化的变量，恢复成原有的PHP变量。

\_\_sleep()：序列化时调用，serialize() 函数会检查类中是否存在该魔术方法。如果存在，该方法会先被调用，然后才执行序列化操作。  
 \_\_wakeup()：unserialize() 会检查是否存在一个 \_\_wakeup() 方法。如果存在，则会先调用该方法，用在反序列化操作中，例如重新建立数据库连接，或执行其它初始化操作。

$name = ['朱','孝','远'];
    
    $serialize_name = serialize($name);
    
    var_dump($serialize_name); //string(48) "a:3:{i:0;s:3:"朱";i:1;s:3:"孝";i:2;s:3:"远";}"
    
    $unserializename = unserialize($serialize_name);
    
    var_dump($unserializename); //array(3) { [0]=> string(3) "朱" [1]=> string(3) "孝" [2]=> string(3) "远" }

看一个序列化对象的例子

class person {
 var $name;
 var $age;
 var $sex;
 
 function __construct($name = "无名氏",$age = null,$sex = null){
 $this->name = $name;
 $this->age = $age;
 $this->sex = $sex;
 }
 
 function show_info(){
 echo 'name：'.$this->name.',age: '.$this->age.',sex: '.$this->sex.' ';
 }
 }
 
 $person = new person('朱某某',21,'男');
 
 var_dump($person); //object(person)#1 (3) { ["name"]=> string(9) "朱某某" ["age"]=> int(21) ["sex"]=> string(3) "男" }
 
 $person->show_info(); // name：朱某某,age: 21,sex: 男
 
 $str = serialize($person);
 
 var_dump($str); //string(79) "O:6:"person":3:{s:4:"name";s:9:"朱某某";s:3:"age";i:21;s:3:"sex";s:3:"男";}"
 
 $p = unserialize($str);
 
 $p->show_info(); // name：朱某某,age: 21,sex: 男

###     ###

### 抽象类和接口 ###

抽象类和接口，都是一种比较特殊的类。抽象类是一种特殊的类，而接口又是一种特殊的抽象类。面向对象的多态就是使用抽象类和接口实现的。

#### 抽象类 ####

抽象的词义是从众多的事物中抽取出共同的，本质的特征。抽象类是指含有一个或多个抽象方法的类，抽象方法是指在声明方法时没有花括弧和方法的具体实现，这些抽象方法是所需要子类共有的特征。要想使用抽象类，就必须使用一个类去继承它并且实现所有的抽象方法。

#### 接口 ####

PHP仅支持单继承，每个类只可以继承一个父类。一个类继承了抽象类，它就不能再有其他父类，为了解决这个问题，PHP引入了接口。

在接口中声明的方法必须都是抽象方法。

<?php
 
 
 /**
 * Class person
 * 类中还有抽象方法，类必须使用abstract修饰
 */
 abstract class person{
 protected $name;
 protected $age;
 protected $sex;
 protected $id;
 
 abstract function say();
 
 abstract public function eat();
 
 abstract function look();
 
 }
 
 interface WorkerInterface{
 function work();
 }
 
 interface TeacherInterface{
 function teaching();
 }
 
 class Worker extends Person implements WorkerInterface{
 protected $workerid;
 public function __construct($name, $age, $sex, $id,$workerid){
 $this->name = $name;
 $this->age = $age;
 $this->sex = $sex;
 $this->id = $id;
 $this->workerid = $workerid;
 }
 
 function say(){
 echo "工人说";
 }
 
 public function eat(){
 echo "工人吃";
 }
 
 function look(){
 echo "工人看";
 }
 
 function work(){
 echo '工人工作';
 }
 }
 
 class Teacher extends Person implements TeacherInterface{
 protected $teacherid;
 public function __construct($name, $age, $sex, $id,$teacherid){
 $this->name = $name;
 $this->age = $age;
 $this->sex = $sex;
 $this->id = $id;
 $this->teacherid = $teacherid;
 }
 
 function say(){
 echo "教师说";
 }
 
 public function eat(){
 echo "教师吃";
 }
 
 function look(){
 echo "教师看";
 }
 
 function teaching(){
 echo '教师教学';
 }
 }
 
 $w = new Worker('张三', 19, '男', '20170518001', '20170518111');
 $t = new Teacher('李霞', 22, '女', '20170518002', '20170518121');
 
 $w->work();
 $t->teaching();

#### 抽象类和接口的区别 ####

1.  抽象类和接口都不能直接创建对象，都需要子类实现。一个子类可以同时实现多个接口，但只能继承一个抽象类。

2.  声明不一样，抽象类使用关键字abstract来修饰，接口使用关键字interface修饰。

3.  实现方式不一样，抽象类通过类的继承，使用关键字extends实现。接口是通过implements实现。一个类不可以直接使用extends继承接口，但是接口和接口之间可以使用extends关键字进行扩展。

4.  抽象类中只要有一个抽象方法即为抽象类，即可使用abstract关键字来修饰声明。接口中所有方法都是抽象方法并且不需要使用abstract关键字去修饰方法。

5.  抽象类中方法还可以使用protected，public来修饰，最低是protected。接口中方法只能使用public来修饰(默认)。

6.  抽象类中可以声明构造函数，接口中不可以声明构造函数。