PHP-面向对象编程教程

迷南。 2021-09-07 05:59 733阅读 0赞

## 1.2 面向对象介绍 ##

1.2.1 介绍

面向对象是一个编程思想。编程思想有面向过程和面向对象

面向过程：编程思路集中的是过程上

面向对象：编程思路集中在参与的对象

以去饭馆吃饭为例：

面向过程：点菜——做菜——上菜——吃饭——结账——收拾

面向对象：服务员，厨师，客人

1.2.2 面向对象的好处

1.  多人合作方便
2.  减少代码冗余，灵活性高
3.  代码的可重用性发挥到极致
4.  可扩展性强

多学一招：
    OOP：面向对象编程（Object Oriented Programming，面向对象编程）
    OOA: 面向对象分析(Object-Oriented Analysis,OOA)
    OOD: 面向对象设计（Object-Oriented Design，OOD）

## 1.3 类和对象 ##

1、对象是具体存在的事物，对象是由属性（变量）和方法（函数）组成的

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjUyODI2Ng_size_16_color_FFFFFF_t_70]

2、类是具有相同属性和行为的一组对象的集合

分析：做菜动作——厨师对象——厨师类  
结论：我们在开发的时候，先写类，通过类创建对象，然后调用对象的属性和方法实现功能。 类——对象——调用成员

注意：一个类可以创建多个对象

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjUyODI2Ng_size_16_color_FFFFFF_t_70 1]

小结：

1、对象是由属性和方法组成的

2、类是所有对象的相同属性和方法的集合

3、在开发的时候先写类，通过类创建对象，通过对象调用方法和属性

4、一个类可以创建多个对象

## 1.4 在PHP中实现类和对象 ##

1.4.1 创建类

语法：

class 类名{
    	//属性
    	//方法
    	//常量
    }
    类是由属性、方法、常量组成的，也可以说
    类成员有：属性、方法、常量

类名的命名规则：

1.  以字母、下划线开头，后面跟的是字母、数字、下划线
2.  不能用PHP关键字做类名
3.  类名不区分大小写（变量名区分，关键字、类名不区分大小写）
4.  类名用帕斯卡命名法（大驼峰 单词的首字母大写）

<?php
 class Student {
 }

1.4.2 对象实例化

通过new关键字来实例化对象。

<?php
 //定义类
 class Student {
 	
 }
 //实例化对象
 $stu1=new Student();
 $stu2=new Student;		//小括号可以省略
 var_dump($stu1,$stu2);	//object(Student)#1 (0) { } object(Student)#2 (0) { }

1.4.3 对象的比较

**注意：对象的传递是地址传递**

相等：结构和保存的值一样就相等  
全等：指向同一个对象才是全等。

<?php
 //定义类
 class Student {
 	
 }
 //实例化对象
 $stu1=new Student();
 $stu2=new Student;
 $stu3=$stu2; //对象传递的是地址	
 //var_dump($stu1,$stu2,$stu3); //object(Student)#1 (0) { } object(Student)#2 (0) { } object(Student)#2 (0) { } 
 //对象比较
 var_dump($stu1==$stu2);		//bool(true) ,比较对象的结构
 echo ' ';
 var_dump($stu1===$stu2);	//bool(false) $stu1和$stu2是否是同一个对象
 echo ' ';
 var_dump($stu2===$stu3);	//bool(true) $stu2和$stu3是同一个对象

## 1.5 属性 ##

属性本质就是变量

通过`->`调用对象的成员 对象名->属性名 对象名->方法名()

<?php
 //定义类
 class Student {
 	public $name;				//属性
 	public $add='地址不详';		//属性
 }
 //实例化对象
 $stu=new Student();
 //print_r($stu);	//Student Object ( [name] => [add] => 地址不详 ) 
 //操作属性
 //1、给属性赋值
 $stu->name='tom';
 $stu->add='北京';
 
 //2、获取属性的值
 echo '姓名：'.$stu->name,' ';	//姓名：tom
 echo '地址：'.$stu->add,' ';		//地址：北京
 
 //3、添加属性
 $stu->age=20;
 print_r($stu);	//Student Object ( [name] => tom [add] => 北京 [age] => 20 ) 
 echo ' ';
 //4、删除属性
 unset($stu->add);
 print_r($stu);	//Student Object ( [name] => tom [age] => 20 )

## 1.6 方法 ##

方法的本质就是函数

<?php
 class Student {
 	//定义方法
 	public function show() {
 		echo '这是show方法 ';
 	}
 	//public可以省略，如果省略，默认就是public
 	function test() {
 		echo '这是test方法 ';
 	}
 }
 $stu=new Student;
 $stu->show();	//调用方法
 $stu->test();

多学一招：

1、方法前面public是可以省略的，如果省略，默认就是public的。

2、属性前面的public不能省略

## 1.7 访问修饰符 ##

用来控制成员的访问权限

<table> 
 <thead> 
 <tr> 
 <th>修饰符</th> 
 <th>描述</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>public（公有的）</td> 
 <td>在类的内部和外部都能访问</td> 
 </tr> 
 <tr> 
 <td>private（私有的）</td> 
 <td>只能在类的内部访问</td> 
 </tr> 
 <tr> 
 <td>protected（受保护的）</td> 
 <td>在整个继承链上访问</td> 
 </tr> 
 </tbody> 
</table>

\*\*多学一招：\*\*一般来说，属性都用私有的，通过公有的方法对私有的属性进行赋值和取值。

作用：保证数据的合法性

<?php
 //访问修饰符
 class Student {
 	private $name;	//私有属性
 	private $sex;	//私有属性
 	//通过公有的方法对私有的属性进行赋值
 	public function setInfo($name,$sex) {
 		if($sex!='男' && $sex!='女'){
 			echo '性别必须是男或女';
 			exit;
 		}
 		$this->name=$name; //$this表示当前对象
 		$this->sex=$sex;
 	}
 	//显示信息
 	public function getInfo() {
 		echo '姓名：'.$this->name,' ';
 		echo '性别：'.$this->sex,' ';
 	}
 }
 //实例化
 $stu=new Student;
 $stu->setInfo('tom','男');
 $stu->getInfo();
 echo '<hr>';
 $stu2=new Student;
 $stu2->setInfo('berry','女');
 $stu2->getInfo();

提示：$this表示调用当前方法的对象

运行结果

![在这里插入图片描述][20200327110249260.png]

## 1.8 类和对象在内存中的分布 ##

1.  对象的本质是一个复杂的变量
2.  类的本质是一个自定义的复杂数据类型
3.  栈区：运行速度快，体积小，保存基本类型
4.  堆区：运行速度稍慢，体积大，保存复杂类型
5.  实例化的过程就是分配内存空间的过程
6.  对象保存在堆区，将堆区的地址保存到栈区。

分析如下代码的结构

<?php
 class Student {
 	public $name;
 	public $sex;
 	public function show() {
 	}
 }
 
 $stu1=new Student;
 $stu2=new Student;
 
 $stu1->show();

示意图

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjUyODI2Ng_size_16_color_FFFFFF_t_70 2]

## 1.9 封装 ##

封装就是有选择性的提供数据

通过访问修饰符来实现封装

## 1.10 构造方法 ##

1.10.1 介绍

构造方法也叫构造函数，当实例化对象的时候自动执行。  
语法：

function __construct(){
    }
    注意：前面是两个下划线

例题

<?php
 class Student {
 	public function __construct() {
 		echo '这是构造方法 ';
 	}
 }
 new Student();	//这是构造方法
 new Student();	//这是构造方法

注意：在其他语言里，与类名同名的函数是构造函数，在PHP中不允许这种写法。

class Student {
 	//和类名同名的方法是构造方法，PHP中不建议使用
 	public function Student() {
 		echo '这是构造方法 ';
 	}
 }
 /*
 Deprecated: Methods with the same name as their class will not be constructors in a future version of PHP; Student has a deprecated constructor in F:\wamp\www\6-demo.php on line 2
 这是构造方法
 */

1.10.2 构造函数作用：初始化成员变量

<?php
 class Student {
 	private $name;
 	private $sex;
 	//构造函数初始化成员变量
 	public function __construct($name,$sex) {
 		$this->name=$name;
 		$this->sex=$sex;
 	}
 	//显示信息
 	public function show() {
 		echo "姓名：{$this->name} ";
 		echo "性别：{$this->sex} ";
 	}
 }
 //实例化
 $stu=new Student('tom','男');
 $stu->show();
 //运行结果
 /*
 姓名：tom
 性别：男
 */

注意：构造函数可以带参数，但不能有return。

## .11 析构方法 ##

1.11.1 介绍

当对象销毁的时候自动调用

语法

function __destruct(){
    }

脚下留心：析构函数不可以带参数

例题

<?php
 class Student {
 	private $name;
 	//构造方法
 	public function __construct($name) {
 		$this->name=$name;
 		echo "{$name}出生了 ";
 	}
 	//析构方法
 	public function __destruct() {
 		echo "{$this->name}销毁了 ";
 	}
 }
 //测试
 $stu1=new Student('tom');
 $stu2=new Student('berry');
 $stu3=new Student('ketty');
 echo '<hr>';

运行结果

![在这里插入图片描述][20200327110212635.png]

1.11.2 计算机的内存管理

计算机内存管理方式：先进先出，先进后出

先进先出的内存管理方式一般用在业务逻辑中，比如秒杀、购票等等

![在这里插入图片描述][20200327110202832.png]

先进后出是计算机的默认内存管理方式

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjUyODI2Ng_size_16_color_FFFFFF_t_70 3]

1.11.3 思考题

思考题1

思考题2

<?php
 class Student {
 	private $name;
 	//构造方法
 	public function __construct($name) {
 		$this->name=$name;
 		echo "{$name}出生了 ";
 	}
 	//析构方法
 	public function __destruct() {
 		echo "{$this->name}销毁了 ";
 	}
 }
 //测试
 new Student('tom');
 new Student('berry');
 new Student('ketty');
 /*
 tom出生了
 tom销毁了
 berry出生了
 berry销毁了
 ketty出生了
 ketty销毁了
 */

思考题3

<?php
 class Student {
 	private $name;
 	//构造方法
 	public function __construct($name) {
 		$this->name=$name;
 		echo "{$name}出生了 ";
 	}
 	//析构方法
 	public function __destruct() {
 		echo "{$this->name}销毁了 ";
 	}
 }
 //测试
 $stu=new Student('tom');
 $stu=new Student('berry');
 $stu=new Student('ketty');
 /*
 tom出生了
 berry出生了
 tom销毁了
 ketty出生了
 berry销毁了
 ketty销毁了
 */

## 1.12 继承 ##

1.12.1 继承介绍

1.  继承使得代码具有层次结构
2.  子类继承了父类的属性和方法，实现了代码的可重用性。
3.  使用extends关键字实现继承
4.  父类和子类是相对的

语法

class 子类 extends 父类{
    }

例题

<?php
 //父类
 class Person {
 	public function show() {
 		echo '这是人类 ';
 	}
 }
 //子类继承父类
 class Student extends Person {
 }
 //测试
 $stu=new Student;
 $stu->show();			//这是人类

执行过程：

第一步：在Student类中查找show()，如果找到就调用，找不到就到父类中查找

第二步：在Person类中查询show()

1.12.2 子类中调用父类成员

<?php
 //父类
 class Person {
 	public function show() {
 		echo '这是人类 ';
 	}
 }
 //子类
 class Student extends Person {
 	public function test() {
 		//方法一；
 		/*
 		$person=new Person();
 		$person->show();		//这是人类
 		*/
 		//方法二
 		$this->show();			//这是人类
 	}
 }
 //测试
 $stu=new Student;
 $stu->test();

小结：

1、方法一：通过实例化父类调用父类的成员

2、方法二：通过$this关键字调用父类的成员

1.12.3 protected

protected：受保护的，在整个继承链上使用

例题：

//例题一：
 <?php
 class A {
 	protected $num=10;	//在整个继承链上访问
 }
 class B extends A {	
 	public function getNum() {
 		echo $this->num;
 	}
 }
 //测试
 $obj=new B(); //整个继承链上有A和B
 $obj->getNum();		//10
 
 //例题二：
 <?php
 class A {
 	public function getNum() {
 		echo $this->num;
 	}
 }
 class B extends A {
 	protected $num=10;	
 }
 //测试
 $obj=new B();	//整个继承链上有A和B
 $obj->getNum();		//10
 
 //例题三：
 <?php
 class A {
 	public function getNum() {
 		echo $this->num;
 	}
 }
 class B extends A {
 	protected $num=10;	
 }
 //测试
 $obj=new A(); //整个继承链上只有A
 $obj->getNum();	 //Notice: Undefined property: A::$num

1.12.4 继承中的构造函数

规则：

1、如果子类有构造函数就调用子类的，如果子类没有就调用父类的构造函数。
    
    2、子类的构造函数调用后，默认不再调用父类的构造函数

通过类名调用父类的构造函数

类名::__construct()

例题

<?php
 class Person {
 //父类的构造函数
 	public function __construct() {
 		echo '这是父类 ';
 	}
 }
 class Student extends Person {
 //子类的构造函数
 	public function __construct() {
 		Person::__construct();		//通过父类的名字调用父类的构造函数
 		parent::__construct();		//parent表示父类的名字
 		echo '这是子类 ';
 	}
 }
 //测试
 new Student();

注意：parent关键字表示父类的名字，可以降低程序的耦合性

例题：给父类传递参数

<?php
 class Person {
 	protected $name;
 	protected $sex;
 //父类的构造函数
 	public function __construct($name,$sex) {
 		$this->name=$name;
 		$this->sex=$sex;
 	}
 }
 class Student extends Person {
 	private $score;
 //子类的构造函数
 	public function __construct($name,$sex,$score) {
 		parent::__construct($name,$sex); //调用父类构造函数并传递参数
 		$this->score=$score;
 	}
 //显示信息
 	public function getInfo() {
 		echo "姓名：{$this->name} ";
 		echo "性别：{$this->sex} ";
 		echo "成绩：{$this->score}";
 	}
 }
 //测试
 $stu=new Student('tom','男',88);
 $stu->getInfo();
 /*
 姓名：tom
 性别：男
 成绩：88
 */

1.12.5 $this详解

t h i s 表 示 当 前 对 象 的 引 用 ， 也 就 是 是 或 this表示当前对象的引用，也就是是或this表示当前对象的引用，也就是是或this保存的当前对象的地址

<?php
 class A {
 	public function __construct() {
 		var_dump($this);
 	}
 }
 class B extends A {
 	
 }
 new A();	//object(A)#1 (0) { } 
 echo ' ';
 new B();	//object(B)#1 (0) { }

1.12.6 多重继承

PHP不允许多重继承，因为多重继承容易产生二义性

![在这里插入图片描述][20200327110110900.png]

如何实现C继承A和B，使用继承链

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjUyODI2Ng_size_16_color_FFFFFF_t_70 4]

## 1.13 多态 ##

多态：多种形态。

多态分为两种：方法重写和方法重载

1.13.1 方法重写

子类重写了父类的同名的方法

<?php
 //父类
 class Person {
 	public function show() {
 		echo '这是父类 ';
 	}
 }
 //子类
 class Student extends Person {
 	//子类重写了父类的同名方法
 	public function show() {
 		echo '这是子类 ';
 	}
 }
 //测试
 $stu=new Student;
 $stu->show();			//这是子类

注意事项：

1.  子类的方法必须和父类的方法同名
2.  参数个数要一致
3.  子类修饰的不能比父类更加严格

1.13.2 方法重载

在同一个类中，有多个同名的函数，通过参数的不同来区分不同的方法，称为方法重载

**注意：PHP不支持方法重载，但是PHP可以通过其他方法来模拟方法重载。**

## 1.14 私有属性继承和重写 ##

私有属性可以继承但不能重写。

<?php
 class A {
 	private $name='PHP';
 	public function showA() {
 		//var_dump($this);	//object(B)#1 (2) { ["name":"B":private]=> string(4) "Java" ["name":"A":private]=> string(3) "PHP" } 
 		echo $this->name,' ';	//PHP
 	}
 }
 class B extends A {
 	private $name='Java';
 	public function showB() {
 		//var_dump($this);	//object(B)#1 (2) { ["name":"B":private]=> string(4) "Java" ["name":"A":private]=> string(3) "PHP" } 
 		echo $this->name,' ';	//Java
 	}
 }
 $obj=new B();
 $obj->showA();
 $obj->showB();
 /*分析：
 showA()和showB()中的$this都表示B的对象，B中继承了A的私有属性，所以B中有两个$name.
 在showA()中只能访问A中的$name，不能访问B中的$name
 在showB()中只能访问B中的$name,不能访问A中的$name
 */

练习一

<?php
 class A {
 	protected $name='tom';	
 	public function showA() {
 		echo $this->name,' ';
 	}
 }
 class B extends A {
 	public $name='berry';
 	public function showB() {
 		echo $this->name,' ';
 	}
 }
 //测试
 $obj=new B();
 $obj->showA();	//berry
 $obj->showB();	//berry
 
 /*
 分析：B中将A的$name重写，所以$obj中只有一个$name,($name='berry'),不管$this在哪个方法中访问，就只能访问这个$name
 */

练习二

<?php
 class A {
 	private $name='tom';	
 	public function showA() {
 		echo $this->name,' ';
 	}
 }
 class B extends A {
 	public $name='berry';
 	public function showB() {
 		echo $this->name,' ';
 	}
 }
 //测试
 $obj=new B();
 $obj->showA();	//tom
 $obj->showB();	//berry
 /*
 分析：
 $obj中有两个$name,一个是私有的，一个是公有的
 在showA()中既能访问私有的$name,也能访问公有的$name,但是私有的比公有的权限高，所以输出tom
 在showB()中不能访问私有的$name,只能访问公有的$name，所以输出berry
 */

## 1.15 方法修饰符 ##

方法修饰符有：static、final、abstract

1.15.1 static【静态的】

1.  static修饰的属性叫静态属性、static修饰的方法叫静态方法
2.  静态成员加载类的时候分配空间，程序执行完毕后销毁
3.  静态成员在内存中就一份。
4.  调用语法 类名::属性 类名::方法名()

<?php
 class Person {
 	public static $add='北京'; // 修饰符之间没有顺序
 	static public function show() {
 		echo '这是一个静态的方法 ';
 	}
 }
 echo Person::$add,' ';		//北京
 Person::show();					//这是一个静态的方法

练习：统计在线人数

<?php
 class Student {
 	private static $num=0;	//静态变量，在内存中就一份
 	public function __construct() {
 		self::$num++; //self表示所在类的类名
 	}
 	public function __destruct() {
 		self::$num--;
 	}
 	public function show() {
 		echo '总人数是：'.self::$num,' ';
 	}
 }
 //测试
 $stu1=new Student;
 $stu2=new Student;
 $stu3=new Student;
 $stu2->show();			//总人数是：3
 unset($stu2);
 $stu3->show();			//总人数是：2

\*\*注意：\*\*self表示所在类的类名，使用self降低耦合性

静态成员也可以被继承

<?php
 class Person {
 	public static $add='中国';
 	public static function show() {
 		echo '这是人类 ';
 	}
 }
 //继承
 class Student extends Person {	
 }
 //测试
 echo Student::$add,' ';		//中国 通过子类名称访问父类的静态成员
 Student::show();				//这是人类

静态延时绑定

static表示当前对象所属的类

<?php
 class Person {
 	public static $type='人类';
 	public function show1() {
 		//var_dump($this);		//object(Student)#1 (0) { } 
 		//echo self::$type,' ';	//人类
 		echo static::$type,' ';			//学生 延时绑定
 	}
 }
 class Student extends Person {
 	public static $type='学生';
 	public function show2() {
 		//var_dump($this);		//object(Student)#1 (0) { } 
 		//echo self::$type,' ';	//学生
 		echo static::$type,' ';			//学生
 	}
 }
 //测试
 $obj=new Student();
 $obj->show1();
 $obj->show2();

小结：

1、static在内存中就一份，在类加载的时候分配空间

2、如果有多个修饰符，修饰符之间是没有顺序的

3、self表示所在类的类名

4、static表示当前对象所属的类

5、static有两个作用，第一表示静态的，第二表示类名

### 1.15.2 final【最终的】 ###

### final修饰的方法不能被重写 ###

final修饰的类不能被继承

![在这里插入图片描述][20200327135044686.png]

![在这里插入图片描述][20200327135034683.png]

作用

1、如果一个类确定不被继承，一个方法确定不会被重写，用final修饰可以提高执行效率。

2、如果一个方法不允许被其他类重写，可以用final修饰。

### 1.15.3 abstract【抽象的】 ###

1.  abstract修饰的方法是抽象方法，修饰的类是抽象类
2.  只有方法的声明没有方法的实现称为抽象方法
3.  一个类中只要有一个方法是抽象方法，这个类必须是抽象类。
4.  抽象类的特点是不能被实例化
5.  子类继承了抽象类，就必须重新实现父类的所有的抽象方法，否则不允许实例化
6.  类中没有抽象方法也可以声明成抽象类，用来阻止类的实例化

例题

<?php
 //抽象类
 abstract class Person {
 	public abstract function setInfo();	//抽象方法
 	public function getInfo() {
 		echo '获取信息 ';
 	}
 }
 //继承
 class Student extends Person {
 //重写实现父类的抽象方法
 	public function setInfo() {
 		echo '重新实现父类的抽象方法 ';
 	}
 }
 //测试
 $stu=new Student;
 $stu->setInfo();		//重新实现父类的抽象方法
 $stu->getInfo();		//获取信息

抽象类的作用：

1定义命名规范

![在这里插入图片描述][2020032713502387.png]

2、阻止实例化，如果一个类中所有的方法都是静态方法，这时候没有必要去实例化，可以通过abstract来阻止来的实例化。

## 1.16 类常量 ##

类常量是const常量

<?php
 class Student {
 	//public const ADD； 	//7.1以后才支持访问修饰符
 	const ADD='地址不详';
 }
 echo Student::ADD;

问题：define常量和const常量的区别？

答：const常量可以做类成员，define常量不可以做类成员。

问题：常量和静态的属性的区别？

答：相同点：都在加载类的时候分配空间

不同点：常量的值不可以更改，静态属性的值可以更改

## 1.17 接口（interface） ##

1.17.1 接口

1.  如果一个类中所有的方法是都是抽象方法，那么这个抽象类可以声明成接口
2.  接口是一个特殊的抽象类，接口中只能有抽象方法和常量
3.  **接口中的抽象方法只能是public**，可以省略，默认也是public的
4.  通过implements关键字来实现接口
5.  不能使用abstract和final来修饰接口中的抽象方法。

<?php
 //声明接口
 interface IPerson {
 	const ADD='中国';
 	function fun1();
 	function fun2();
 }
 //接口实现
 class Student implements IPerson {
 	public function fun1() {
 		
 	}
 	public function fun2() {
 		
 	}
 }
 //访问接口中的常量
 echo IPerson::ADD;

1.17.2 接口的多重实现

类不允许多重继承，但是接口允许多重实现。

<?php
 interface IPic1 {
 	function fun1();
 }
 interface IPic2 {
 	function fun2();
 }
 //接口允许多重实现
 class Student implements IPic1,IPic2 {
 	public function fun1() {
 		
 	}
 	public function fun2() {
 		
 	}
 }

注意：

1、在接口的多重实现中，如果有同名的方法，只要实现一次即可

2、类可以继承的同时实现接口

class Student extends Person implements IPIc1,IPic1{
        
    }

## 1.18 匿名类 ##

这是了解的内容，PHP7.0支持

<?php
 $stu=new class {
 	public $name='tom';
 	public function __construct() {
 		echo '构造函数 ';
 	}
 };
 echo $stu->name;
 /*运行结果；
 构造函数
 tom
 */

小结：

1、如果类只被实例化一次就可以使用匿名类

2、好处，在执行的过程中，类不占用空间

## 1.19 方法绑定 ##

这是了解的内容，PHP7.0支持

作用：将方法绑定到对象上，并调用

语法：

闭包->call(对象)：将闭包绑定到对象上,并调用

在PHP中匿名函数称为闭包

例题

<?php
 $lang='en';
 //类
 class Student{
 }
 //匿名函数
 if($lang=='ch'){
 	$fun=function(){
 		echo '我是一名学生';
 	};
 }else{
 	$fun=function(){
 		echo 'i am a studnet';
 	};
 }
 //绑定
 $stu=new Student;
 $fun->call($stu);	//i am a studnet

## 1.20 自动加载类 ##

在项目开发中，因为一个文件中只能写一个类，并且在执行过程中会有很多的类参与，如果一个一个的加载很麻烦，所以，就需要一个机制实现在PHP执行过程中自动加载需要的类。

1.20.1 类的规则

1.  一个文件中只能放一个类（必须）
2.  文件名和类名同名（必须）
3.  类文件以.class.php结尾（不是必须）

1.20.2 手动加载类

1、创建`Goods.class.php`页面

<?php
 //商品类
 abstract class Goods {
 	protected $name;
 	final public function setName($name) {
 		$this->name=$name;	
 	}
 	public abstract function getName();
 }

2、创建Book.class.php页面

<?php
 //图书类
 class Book extends Goods {
 	public function getName() {
 		echo "《{$this->name}》 ";
 	}
 }

3、创建Phone.class.php页面

<?php
 //电话类
 class Phone extends Goods {
 	public function getName() {
 		echo $this->name,' ';
 	}
 }

4、在PHP页面上加载类文件

<?php
 require './Goods.class.php'; //手动加载类文件
 require './Book.class.php';		//手动加载类文件
 require './Phone.class.php';	//手动加载类文件
 //测试
 $book=new Book();
 $book->setName('面向对象编程');
 $phone=new Phone();
 $phone->setName('苹果6s');
 $book->getName();
 $phone->getName();

运行结果

![在这里插入图片描述][20200327140608728.png]

1.20.3 自动加载类

当缺少类的时候自动的调用`__autoload()`函数，并且将缺少的类名作为参数传递给`__autoload()`。

<?php
 /*
 *作用：自动加载类
 *@param $class_name string 缺少的类名
 */
 function __autoload($class_name) {
 	require "./{$class_name}.class.php";
 }
 //测试
 $book=new Book();
 $book->setName('面向对象编程');
 $phone=new Phone();
 $phone->setName('苹果6s');
 $book->getName();
 $phone->getName();

注意：\_\_autoload()函数在PHP7.2以后就不支持了。

1.20.4 注册加载类

通过spl\_autoload\_register()注册\_\_autoload()函数

<?php
 //方法一：
 /*
 //加载类函数
 function loadClass($class_name) {
 	require "./{$class_name}.class.php";
 }
 //注册加载类函数
 spl_autoload_register('loadClass');
 */
 
 //方法二：
 spl_autoload_register(function($class_name){
 	require "./{$class_name}.class.php";
 });
 
 //测试
 $book=new Book();
 $book->setName('面向对象编程');
 $phone=new Phone();
 $phone->setName('苹果6s');
 $book->getName();
 $phone->getName();

1、spl\_autoload\_register()可以注册多个自动加载函数

<?php
 function load1($class) {
 	require "./{$class}.class.php";
 }
 function load2($class) {
 	require "./{$class}.php";
 }
 function load3($class) {
 	require "./{$class}.fun.php";
 }
 spl_autoload_register('load1');
 spl_autoload_register('load2');
 spl_autoload_register('load3');

2、PHP5.1以后就开始支持此函数。

1.20.5 类文件存储不规则的加载方法

将类名和文件地址做一个映射，组成一个关联数组。

$map=array(
        //类名	=>	类文件地址
    	'Goods'	=>	'./aa/Goods.class.php',
    	'Book'	=>	'./bb/Book.class.php',
    	'Phone'	=>	'./cc/Phone.class.php'
    );

代码如下

<?php
 spl_autoload_register(function($class_name){
 	//类名和文件地址映射成一个关联数组
 	$map=array(
 		'Goods'	=>	'./aa/Goods.class.php',
 		'Book'	=>	'./bb/Book.class.php',
 		'Phone'	=>	'./cc/Phone.class.php'
 	);
 	//在映射数组中找到就包含
 	if(isset($map[$class_name]))
 		require $map[$class_name];
 });
 //测试
 $book=new Book();
 $book->setName('面向对象编程');
 $phone=new Phone();
 $phone->setName('苹果6s');
 $book->getName();
 $phone->getName();

在项目中，绝大部分都是规则存储的，不规则的比较少。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjUyODI2Ng_size_16_color_FFFFFF_t_70]: /images/20210813/a5c5a54bff224bf29179887b01ddabea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjUyODI2Ng_size_16_color_FFFFFF_t_70 1]: /images/20210813/891274bd040241938e9ced6c3d53ac0d.png
[20200327110249260.png]: /images/20210813/b5a8a09ade284278b0ee3241acd73f1f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjUyODI2Ng_size_16_color_FFFFFF_t_70 2]: /images/20210813/cef5977de1e4435a94e4445c066f2fe4.png
[20200327110212635.png]: /images/20210813/85fe88bb76364c42ab97910f7a5a4cf2.png
[20200327110202832.png]: /images/20210813/4f8d3fc66a0042e0b2d6feef34d37247.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjUyODI2Ng_size_16_color_FFFFFF_t_70 3]: /images/20210813/2977c1dc1a074c64bbba7b723be640f7.png
[20200327110110900.png]: /images/20210813/f83fdf742d074589ac7dd56c1cc4b6d9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjUyODI2Ng_size_16_color_FFFFFF_t_70 4]: /images/20210813/0b52cbe1416e4fb1b92b08a4a6ecccf6.png
[20200327135044686.png]: /images/20210813/d21d88af34a14ad695714966a8a1fac2.png
[20200327135034683.png]: /images/20210813/64be118defed4cafa9c8c1d3ffd45b16.png
[2020032713502387.png]: /images/20210813/7782b476620342a08bf0e4d4ee34d04b.png
[20200327140608728.png]: /images/20210813/b32c3a1f670d419996a81c045d322b5a.png