PHP面向对象的三大特征: 继承,封装,多态
一.继承
1、如何实现继承?
给子类使用extends关键字,让子类继承父类;
class Student extends Person{}
2、实现继承的注意事项?
① 子类只能继承父类的非私有属性。
②子类继承父类后,相当于将父类的属性和方法copy到子类,可以直接使用$this调用。
③ PHP只能单继承,不支持一个类继承多个类。但是一个类进行多层继承;
1
2
3
4
5
6
7
|
class Person{}
class Chengnian extends Person{}
class Student extends Chengnian{}
//Student类就同时具有了Chengnian类和Person类的属性和方法
|
3、方法覆盖(方法重写)
条件① 子类继承父类。
条件② 子类重写父类已有方法。
符合上述两个条件,称为方法覆盖。覆盖之后,子类调用方法,将调用子类自己的方法。
同样,除了方法覆盖,子类也可以具有与父类同名的属性,进行属性覆盖。
4、如果,子类重写了父类方法,如何在子类中调用父类同名方法?
partent::方法名();
所以,当子类继承父类时,需在子类的构造中的第一步,首先调用父类构造进行复制。
1
2
3
4
5
6
7
|
function
__construct(
$name
,
$sex
,
$school
){
parent::__construct(
$name
,
$sex
);
$this
->school =
$school
;
}
|
实例一枚:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
class
Student
extends
Person{
//子类继承父类
public
$school
;
function
__construct(
$name
,
$sex
,
$school
){
//子类的构造函数
parent::__construct(
$name
,
$sex
);
//调用父类构造进行复制
$this
->school =
$school
;
}
function
program(){
echo
"PHP真好玩!我爱PHP!PHP是世界上最好用的编程语言!<br>"
;
}
function
say(){
parent::say();
//重写父类的同名方法
echo
"我是{$this->school}的"
;
}
}
$zhangsan
=
new
Student(
"张三"
,
"男"
,
"起航"
);
$zhangsan
->say();
$zhangsan
->program();
|
二、封装
1、什么是封装?
通过访问修饰符,将类中不需要外部访问的属性和方法进行私有化处理,以实现访问控制。
【注意】:是实现访问控制,而不是拒绝访问。 也就是说,我们私有化属性之后,需要提供对应的方法,让用户通过我们提供的方法处理属性。
2、封装的作用?
①使用者只关心类能够提供的功能,而不必关心功能实现的细节!(封装方法)
②对用户的数据进行控制,防止设置不合法数据,控制返回给用户的数据(属性封装+set/get方法)
3、实现封装操作?
① 方法的封装
对于一些只在类内部使用的方法,而不像对外部提供使用。那么,这样的方法我们可以使用private进行私有化处理。
private function formatName(){} //这个方法仅仅能在类内部使用$this调用
function showName(){
$this -> formatName();
}
②属性的封装+set/get方法
为了控制属性的设置以及读取,可以将属性进行私有化处理,并要求用户通过我们提供的set/get方法进行设置
private $age;
function setAge($age){
$this->age = $age;
}
function getAge(){
return $this->age;
}
$对象 -> getAge();
$对象 -> setAge(12);
③ 属性的封装+魔术方法
private $age;
function __get($key){
return $this->$key;
}
function __set($key,$value){
$this->$key=$value;
}
$对象->age; // 访问对象私有属性时,自动调用__get()魔术方法,并且将访问的属性名传给__get()方法;
$对象->age=12; // 设置对象私有属性时,自动调用__set()魔术方法,并且将设置的属性名以及属性值传给__set()方法;
【 注意】:在魔术方法中,可以使用分支结构,判断$key的不同,进行不同操作。
4、关于封装的魔术方法:
① __set($key,$value):给类私有属性赋值时自动调用,调用时给方法传递两个参数:需要设置的属性名、属性值;
② __get($key):读取类私有属性时自动调用,调用时给方法传递一个参数:需要读取的属性名;
③ __isset($key):外部使用isset()函数检测私有属性时,自动调用。
>>> 类外部使用isset();检测私有属性,默认是检测不到的。false
>>> 所以,我们可以使用__isset();函数,在自动调用时,返回内部检测结果。
1
2
3
|
function __isset($key){
return isset($this->$key);
}
|
当外部使用isset($对象名->私有属性);检测时,将自动调用上述__isset()返回的结果!
④ __unset($key):外部使用unset()函数删除私有属性时,自动调用;
1
2
3
|
function __unset($key){
unset($this->$key);
}
|
当外部使用unset($对象名->私有属性);删除属性时,自动将属性名传给__unset(),并交由这个魔术方法处理。
实例一枚
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
|
class
Person{
public
$name
;
public
$age
;
public
$sex
;
function
__construct(
$name
,
$age
,
$sex
){
$this
->name=
$name
;
$this
->setAge(
$age
);
$this
->setSex(
$sex
);
}
function
setAge(
$age
){
if
(
$age
>=0&&
$age
<=120){
return
$this
->age=
$age
;
}
else
{
die
(
"年龄输入有误!!!"
);
}
}
function
setSex(
$sex
){
if
(
$sex
==
"女"
||
$sex
==
"男"
){
return
$this
->sex=
$sex
;
}
else
{
die
(
"性别输入有误!!!"
);
}
}
function
say(){
echo
"我的名字叫{$this->name},我的年龄{$this->age},我的性别是{$this->sex}<br>"
;
}
}
class
Work
extends
Person{
private
$position
;
function
__construct(
$name
,
$age
,
$sex
,
$position
){
parent::__construct(
$name
,
$age
,
$sex
);
$this
->job=
$job
;
$this
->setPosition(
$position
);
}
function
setPosition(
$position
){
$arr
=[
'总监'
,
'董事长'
,
'程序员'
,
'清洁工'
];
if
(in_array(
$position
,
$arr
)){
return
$this
->position=
$position
;
}
else
{
die
(
"不存在该职位"
);
}
}
function
__set(
$key
,
$value
){
if
(
$key
==
"age"
){
return
parent::setAge(
$value
);
}
elseif
(
$key
==
"sex"
){
return
parent::setSex(
$value
);
}
elseif
(
$key
==
"position"
){
return
$this
->setPosition(
$value
);
}
return
$this
->
$key
=
$value
;
}
function
say(){
parent::say();
echo
"我的职位是{$this->position}"
;
}
}
$zhangsan
=
new
Work(
"张三"
,22,
"男"
,
"总监"
);
$zhangsan
->setSex(
"女"
);
$zhangsan
->setAge(30);
// $zhangsan->setPosition("董事长");
$zhangsan
->position=
"董事长"
;
$zhangsan
->name=
"lisi"
;
$zhangsan
->say();
|
三.多态
3.1、什么是多态?
多态实现多态的前提是实现继承。
1.一个类被多个子类继承,如果这个类的某个方法在多个子类中表现出不同的功能,我们称这种行为为多态。在PHP中的方法重写,
2.实现多态的必要途径:
⑴子类继承父类;
⑵重写父类方法;
⑶父类引用指向子类对象;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
class Computer{
function fangfa(InkBox $a,Paper $b){ //父类引用
echo "即将开始打印····<
br
>";
$a->color();
$b->sizes();
echo "打印结束···<
br
>";
}
}
class Color implements InkBox{
function color(){
echo "正在装载彩色墨盒<
br
>";
echo "实现彩色墨盒<
br
>";
}
}
class White implements InkBox{
function color(){
echo "正在装载黑白墨盒<
br
>";
echo "实现黑白墨盒<
br
>";
}
}
class A4 implements Paper{
function sizes(){
echo "正在加载A4纸张<
br
>";
echo "实现A4纸张<
br
>";
}
}
class A5 implements Paper{
function sizes(){
echo "实现A5纸张<
br
>";
}
}
$com=new Computer();//创建对象
$com->fangfa(new Color(),new A4());//子类对象
|
以上这篇全面解析PHP面向对象的三大特征就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。