PHP-面向对象编程教程
1.2 面向对象介绍
1.2.1 介绍
面向对象是一个编程思想。编程思想有面向过程和面向对象
面向过程：编程思路集中的是过程上
面向对象：编程思路集中在参与的对象
以去饭馆吃饭为例：
面向过程：点菜——做菜——上菜——吃饭——结账——收拾
面向对象：服务员，厨师，客人
1.2.2 面向对象的好处
- 多人合作方便
- 减少代码冗余，灵活性高
- 代码的可重用性发挥到极致
- 可扩展性强
多学一招：
OOP：面向对象编程（Object Oriented Programming，面向对象编程）
OOA: 面向对象分析(Object-Oriented Analysis,OOA)
OOD: 面向对象设计（Object-Oriented Design，OOD）1.3 类和对象
1、对象是具体存在的事物，对象是由属性（变量）和方法（函数）组成的
2、类是具有相同属性和行为的一组对象的集合
分析：做菜动作——厨师对象——厨师类
结论：我们在开发的时候，先写类，通过类创建对象，然后调用对象的属性和方法实现功能。 类——对象——调用成员
注意：一个类可以创建多个对象
小结：
1、对象是由属性和方法组成的
2、类是所有对象的相同属性和方法的集合
3、在开发的时候先写类，通过类创建对象，通过对象调用方法和属性
4、一个类可以创建多个对象
1.4 在PHP中实现类和对象
1.4.1 创建类
语法：
class 类名{
//属性
//方法
//常量
}
类是由属性、方法、常量组成的，也可以说
类成员有：属性、方法、常量
类名的命名规则：
- 以字母、下划线开头，后面跟的是字母、数字、下划线
- 不能用PHP关键字做类名
- 类名不区分大小写（变量名区分，关键字、类名不区分大小写）
- 类名用帕斯卡命名法（大驼峰 单词的首字母大写）
1.4.2 对象实例化
通过new关键字来实例化对象。
1.4.3 对象的比较
注意：对象的传递是地址传递
相等：结构和保存的值一样就相等
全等：指向同一个对象才是全等。
';
var_dump($stu1===$stu2); //bool(false) $stu1和$stu2是否是同一个对象
echo '
';
var_dump($stu2===$stu3); //bool(true) $stu2和$stu3是同一个对象1.5 属性
属性本质就是变量
通过->调用对象的成员 对象名->属性名 对象名->方法名()
[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 方法
方法的本质就是函数
';
}
//public可以省略，如果省略，默认就是public
function test() {
echo '这是test方法
';
}
}
$stu=new Student;
$stu->show(); //调用方法
$stu->test();
多学一招：
1、方法前面public是可以省略的，如果省略，默认就是public的。
2、属性前面的public不能省略
1.7 访问修饰符
用来控制成员的访问权限
| 修饰符 | 描述 |
|---|---|
| public（公有的） | 在类的内部和外部都能访问 |
| private（私有的） | 只能在类的内部访问 |
| protected（受保护的） | 在整个继承链上访问 |
**多学一招：**一般来说，属性都用私有的，通过公有的方法对私有的属性进行赋值和取值。
作用：保证数据的合法性
name=$name; //$this表示当前对象
$this->sex=$sex;
}
//显示信息
public function getInfo() {
echo '姓名：'.$this->name,'
';
echo '性别：'.$this->sex,'
';
}
}
//实例化
$stu=new Student;
$stu->setInfo('tom','男');
$stu->getInfo();
echo '
';
$stu2=new Student;
$stu2->setInfo('berry','女');
$stu2->getInfo();
提示：$this表示调用当前方法的对象
运行结果
1.8 类和对象在内存中的分布
- 对象的本质是一个复杂的变量
- 类的本质是一个自定义的复杂数据类型
- 栈区：运行速度快，体积小，保存基本类型
- 堆区：运行速度稍慢，体积大，保存复杂类型
- 实例化的过程就是分配内存空间的过程
- 对象保存在堆区，将堆区的地址保存到栈区。
分析如下代码的结构
show();
示意图
1.9 封装
封装就是有选择性的提供数据
通过访问修饰符来实现封装
1.10 构造方法
1.10.1 介绍
构造方法也叫构造函数，当实例化对象的时候自动执行。
语法：
function __construct(){
}
注意：前面是两个下划线
例题
';
}
}
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 构造函数作用：初始化成员变量
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(){
}
脚下留心：析构函数不可以带参数
例题
name=$name;
echo "{$name}出生了
";
}
//析构方法
public function __destruct() {
echo "{$this->name}销毁了
";
}
}
//测试
$stu1=new Student('tom');
$stu2=new Student('berry');
$stu3=new Student('ketty');
echo '
';
运行结果
1.11.2 计算机的内存管理
计算机内存管理方式：先进先出，先进后出
先进先出的内存管理方式一般用在业务逻辑中，比如秒杀、购票等等
先进后出是计算机的默认内存管理方式
1.11.3 思考题
思考题1
name=$name;
echo "{$name}出生了
";
}
//析构方法
public function __destruct() {
echo "{$this->name}销毁了
";
}
}
//测试
$stu1=new Student('tom');
$stu2=new Student('berry');
$stu3=new Student('ketty');
unset($stu2);
echo '
';
/*
tom出生了
berry出生了
ketty出生了
berry销毁了
ketty销毁了
tom销毁了
*/
思考题2
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
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 继承介绍
- 继承使得代码具有层次结构
- 子类继承了父类的属性和方法，实现了代码的可重用性。
- 使用extends关键字实现继承
- 父类和子类是相对的
语法
class 子类 extends 父类{
}
例题
';
}
}
//子类继承父类
class Student extends Person {
}
//测试
$stu=new Student;
$stu->show(); //这是人类
执行过程：
第一步：在Student类中查找show()，如果找到就调用，找不到就到父类中查找
第二步：在Person类中查询show()
1.12.2 子类中调用父类成员
';
}
}
//子类
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：受保护的，在整个继承链上使用
例题：
//例题一：
num;
}
}
//测试
$obj=new B(); //整个继承链上有A和B
$obj->getNum(); //10
//例题二：
num;
}
}
class B extends A {
protected $num=10;
}
//测试
$obj=new B(); //整个继承链上有A和B
$obj->getNum(); //10
//例题三：
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()
例题
';
}
}
class Student extends Person {
//子类的构造函数
public function __construct() {
Person::__construct(); //通过父类的名字调用父类的构造函数
parent::__construct(); //parent表示父类的名字
echo '这是子类
';
}
}
//测试
new Student();
注意：parent关键字表示父类的名字，可以降低程序的耦合性
例题：给父类传递参数
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保存的当前对象的地址
';
new B(); //object(B)#1 (0) { }
1.12.6 多重继承
PHP不允许多重继承，因为多重继承容易产生二义性
如何实现C继承A和B，使用继承链
1.13 多态
多态：多种形态。
多态分为两种：方法重写和方法重载
1.13.1 方法重写
子类重写了父类的同名的方法
';
}
}
//子类
class Student extends Person {
//子类重写了父类的同名方法
public function show() {
echo '这是子类
';
}
}
//测试
$stu=new Student;
$stu->show(); //这是子类
注意事项：
- 子类的方法必须和父类的方法同名
- 参数个数要一致
- 子类修饰的不能比父类更加严格
1.13.2 方法重载
在同一个类中，有多个同名的函数，通过参数的不同来区分不同的方法，称为方法重载
注意：PHP不支持方法重载，但是PHP可以通过其他方法来模拟方法重载。
1.14 私有属性继承和重写
私有属性可以继承但不能重写。
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
*/
练习一
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
*/
练习二
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【静态的】
- static修饰的属性叫静态属性、static修饰的方法叫静态方法
- 静态成员加载类的时候分配空间，程序执行完毕后销毁
- 静态成员在内存中就一份。
- 调用语法 类名::属性 类名::方法名()
';
}
}
echo Person::$add,'
'; //北京
Person::show(); //这是一个静态的方法
练习：统计在线人数
';
}
}
//测试
$stu1=new Student;
$stu2=new Student;
$stu3=new Student;
$stu2->show(); //总人数是：3
unset($stu2);
$stu3->show(); //总人数是：2
**注意：**self表示所在类的类名，使用self降低耦合性
静态成员也可以被继承
';
}
}
//继承
class Student extends Person {
}
//测试
echo Student::$add,'
'; //中国 通过子类名称访问父类的静态成员
Student::show(); //这是人类
静态延时绑定
static表示当前对象所属的类
'; //人类
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修饰的类不能被继承
作用
1、如果一个类确定不被继承，一个方法确定不会被重写，用final修饰可以提高执行效率。
2、如果一个方法不允许被其他类重写，可以用final修饰。
1.15.3 abstract【抽象的】
- abstract修饰的方法是抽象方法，修饰的类是抽象类
- 只有方法的声明没有方法的实现称为抽象方法
- 一个类中只要有一个方法是抽象方法，这个类必须是抽象类。
- 抽象类的特点是不能被实例化
- 子类继承了抽象类，就必须重新实现父类的所有的抽象方法，否则不允许实例化
- 类中没有抽象方法也可以声明成抽象类，用来阻止类的实例化
例题
';
}
}
//继承
class Student extends Person {
//重写实现父类的抽象方法
public function setInfo() {
echo '重新实现父类的抽象方法
';
}
}
//测试
$stu=new Student;
$stu->setInfo(); //重新实现父类的抽象方法
$stu->getInfo(); //获取信息
抽象类的作用：
1定义命名规范
2、阻止实例化，如果一个类中所有的方法都是静态方法，这时候没有必要去实例化，可以通过abstract来阻止来的实例化。
1.16 类常量
类常量是const常量
问题：define常量和const常量的区别？
答：const常量可以做类成员，define常量不可以做类成员。
问题：常量和静态的属性的区别？
答：相同点：都在加载类的时候分配空间
不同点：常量的值不可以更改，静态属性的值可以更改
1.17 接口（interface）
1.17.1 接口
- 如果一个类中所有的方法是都是抽象方法，那么这个抽象类可以声明成接口
- 接口是一个特殊的抽象类，接口中只能有抽象方法和常量
- 接口中的抽象方法只能是public，可以省略，默认也是public的
- 通过implements关键字来实现接口
- 不能使用abstract和final来修饰接口中的抽象方法。
1.17.2 接口的多重实现
类不允许多重继承，但是接口允许多重实现。
注意：
1、在接口的多重实现中，如果有同名的方法，只要实现一次即可
2、类可以继承的同时实现接口
class Student extends Person implements IPIc1,IPic1{
}1.18 匿名类
这是了解的内容，PHP7.0支持
';
}
};
echo $stu->name;
/*运行结果；
构造函数
tom
*/
小结：
1、如果类只被实例化一次就可以使用匿名类
2、好处，在执行的过程中，类不占用空间
1.19 方法绑定
这是了解的内容，PHP7.0支持
作用：将方法绑定到对象上，并调用
语法：
闭包->call(对象)：将闭包绑定到对象上,并调用
在PHP中匿名函数称为闭包
例题
call($stu); //i am a studnet1.20 自动加载类
在项目开发中，因为一个文件中只能写一个类，并且在执行过程中会有很多的类参与，如果一个一个的加载很麻烦，所以，就需要一个机制实现在PHP执行过程中自动加载需要的类。
1.20.1 类的规则
- 一个文件中只能放一个类（必须）
- 文件名和类名同名（必须）
- 类文件以.class.php结尾（不是必须）
1.20.2 手动加载类
1、创建Goods.class.php页面
name=$name;
}
public abstract function getName();
}
2、创建Book.class.php页面
name}》
";
}
}
3、创建Phone.class.php页面
name,'
';
}
}
4、在PHP页面上加载类文件
setName('面向对象编程');
$phone=new Phone();
$phone->setName('苹果6s');
$book->getName();
$phone->getName();
运行结果
1.20.3 自动加载类
当缺少类的时候自动的调用__autoload()函数，并且将缺少的类名作为参数传递给__autoload()。
setName('面向对象编程');
$phone=new Phone();
$phone->setName('苹果6s');
$book->getName();
$phone->getName();
注意：__autoload()函数在PHP7.2以后就不支持了。
1.20.4 注册加载类
通过spl_autoload_register()注册__autoload()函数
setName('面向对象编程');
$phone=new Phone();
$phone->setName('苹果6s');
$book->getName();
$phone->getName();
1、spl_autoload_register()可以注册多个自动加载函数
2、PHP5.1以后就开始支持此函数。
1.20.5 类文件存储不规则的加载方法
将类名和文件地址做一个映射，组成一个关联数组。
$map=array(
//类名 => 类文件地址
'Goods' => './aa/Goods.class.php',
'Book' => './bb/Book.class.php',
'Phone' => './cc/Phone.class.php'
);
代码如下
'./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();
在项目中，绝大部分都是规则存储的，不规则的比较少。