当前位置: 首页 / 网站建设 / 正文

PHP面向对象编程是什么?需要掌握哪些知识

发布时间:2020-09-06 00:15:50 作者:小超越君

本篇文章给大家分享的内容是关于浅谈PHP面向对象编程 ,有着一定的参考价值,有需要的朋友可以参考一下

PHP面向对象编程是什么?

在面向对象的程序设计(英语:Object-oriented programming,缩写:OOP)中,对象是一个由信息及对信息进行处理的描述所组成的整体,是对现实世界的抽象。

在现实世界里我们所面对的事情都是对象,如计算机、电视机、自行车等。

对象的主要三个特性:

对象的行为:可以对 对象施加那些操作,开灯,关灯就是行为。
对象的形态:当施加那些方法是对象如何响应,颜色,尺寸,外型。
对象的表示:对象的表示就相当于身份证,具体区分在相同的行为与状态下有什么不同。

一、PHP面向对象编程基础实践

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
68
69
70
71
72
73
74
75
/*

*    通过对象的编程方式,可将实现生活中的一切事物以对象的形式表现出来。便于理解、维护、扩展等;

*    本示例:定义一个“人”类

*    $name : 对象中的成员属性,在此类中表示人的姓名

*    say() : 对象中的成员方法,在此类中表示人说话的方法

*    $this : PHP中的伪变量,表示自身的类

*    __construct() : php中的魔术方法,构造函数,在实例化类时自动执行

*    __destruct() : php中的魔术方法,析构函数,当类调用完成后自动执行

*/

class Human

{

    public $name;

    public $sex;

    public $age;

    public function __construct($name,$sex,$age)

    {

        $this->name = $name;

        $this->sex = $sex;

        $this->age = $age;

    }

    public function say()

    {

        echo '大家好,我的名字叫'.$this->name.',今年'.$this->age.'岁,我的性别是'.$this->sex;

    }

    public function __destruct()

    {

        $this->name = null;

        $this->sex = null;

        $this->age = null;

    }

}

//实例化“人”类

$male = new Human("张三","男","20");

//调用“人”类说话的方法

$male->say();

 

//输出结果:大家好,我的名字叫张三,今年20岁,我的性别是男

?>

二、PHP面向对象高级编程实践

知识点:类的继承、方法重写、访问控制、static关键字、final关键字、数据访问、接口、多态、抽象类

2.1、类的继承:extends 关键字
例如:一员运行员、一位主持人,他们有人类共同的行为方法,但他们都有自己不同的特长专业。因此在编程时需要给他们创建一个父类并继承;

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
/*

*    创建一个“人”类做为父类,继承的子类都拥有其父类的成员属性、方法

*/

class Human

{

    public $name;

    public function say()

    {

        echo "父类说话的方法,姓名:".$this->name."\n";

    }

    public function eat()

    {

        echo "父类吃饭的方法\n";

    }

}

/*

*    创建一个“运动员”类,继承“人”类

*    extends : 关键字,继承某个类

*/

class Sport extends Human

{

    public $type;  

    public function __construct($name,$type)

    {

        $this->name = $name;    //给父类 $name 属性赋值

        $this->type = $type;  

    }

    public function run()

    {

        $this->say();   //调用父类“说话”的方法

        echo "我在正跑步,我是一员".$this->type."运动员.....\n";

    }

}

/*

*    创建一个“主持人”类,继承“人”类

*    extends : 关键字,继承某个类

*/

class Host extends Human

{

    public $television;

    public function __construct($name,$television)

    {

        $this->name = $name;  

        $this->television= $television;  

    }

    public function perform()

    {

        $this->eat();   //调用父类“吃饭”的方法

        echo "我在正表演一个节目,我是".$this->television."电视台的一名主持人.....\n";

    }

}

 

//实例化“运动员”类

$nba = new Sport("乔丹","篮球");

$nba->run();

 

//实例化“主持人”类

$tv = new Host("张三","北京卫视");

$tv->perform();

 

//输出结果:

//父类说话的方法,姓名:乔丹 我在正跑步,我是一员篮球运动员.....

//父类吃饭的方法 我在正表演一个节目,我是北京卫视电视台的一名主持人.....

?>

2.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
37
class Human

{

    public function say()

    {

        echo "父类说话的方法";

    }

}

class Sport extends Human

{

    //重写父类“说话”的方法

    public function say()

    {

        echo "子类说话的方法";

    }

}

$nba = new Sport();

$nba->say();

//输出结果:子类说话的方法

?>

2.3、访问控制:public 、 protected 、private 关键字
public:定义公共的成员属性或方法,任何地方都可使用
protected : 定义受保护的成员属性或方法,只允许类本身或子类使用
private : 定义私有的成员属性或方法,只允许类的本身使用

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
class Human

{

    public $name;

    protected $sex;

    private $age;

     

}

//实例化对象,给公共属性赋值可正常输出结果,外部不能给protected、private受保护的成员属性赋值或使用

$worker = new Human();

$worker->name = "张三";

echo $worker->name;

 

?>

2.4、static(静态)关键字
1)、静态属性用于保存类的公有数据;
2)、静态方法里面只能访问静态属性或方法,不能使用 $this 伪变量;
3)、静态成员不需要通过 new 关键字来实例化对象就可访问使用;

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
class Human

{

    static $name = "张三";

    static function say()

    {

        echo "我的姓名叫:".self::$name;

    }

}

//外部使用静态成员属性或方法

echo Human::$name;

Human::say();

 

//输出结果:张三  我的姓名叫:张三

?>

2.5、final关键字:不允许成员方法被重写,不允许被继承
例:1、对于父类“吃饭”这个方法,不希望子类重写它;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
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
class Human

{

    final public function eat()

    {

        echo "父类吃饭的方法,不允许子类重写";

    }

}

final class Sport extends Human

{

    public function eat()

    {

        echo "子类吃饭的方法。此时程序将会报致命错误";

    }

}

//创建一个类继承 Sport 这个类。此时程序也将会报致命错误。因为 Sport 类不允许再创建子类

class Student extends Sport

{

    public $name;

}

 

//实例化 Sport 类 ,调用 eat() 方法

$nba = new Sport();

$nba->eat();

 

//实例化 Student 类 ,给 name 属性负值

$obj = new Student();

$obj->name = "张三";

 

//输出结果:Fatal error: Cannot override final method Human::eat() in ******.php on line 15

//Fatal error: Class Student may not inherit from final class (Sport) in ****.php on line 20

?>

2.6、数据访问:$this 、 self 、parent 关键字
$this : 伪变量,代表类的本身,可访问本类及父类中的成员属性与方法。
self : 访问类中的静态成员属性或方法
parent :访问父类的成员属性或方法

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
class Human

{

    static $name = "张三";

}

class Sport extends Human

{

    static function getParentName()

    {

        echo parent::$name;

    }

    public function get()

    {

       self::getParentName();

    }

}

$obj = new Sport();

$obj->get();

//输出结果:张三

?>

2.7、接口:把不同类的共同行为方法进行定义,但不具体实现,由子类来实现具体的方法;
例如:人会吃饭,动物也会吃饭,甚至有些植物也会吃饭,但他们吃饭的方式不一样,因此这时需要定义一个接口类,具体的方式由子类来实现;
定义接口关键字:interface
实现接口方法关键字:implements

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
//定义一个接口类,有吃饭的方法,但不具体实现。

interface ICanEat

{

    public function eat($food);

}

class Human implements ICanEat

{

    //eat()方法必须由子类来实现,否则程序将报致命错误

    public function eat($food)

    {

        echo "I'm eating ".$food;

    }

}

class Animal implements ICanEat

{

    public function eat($food)

    {

        echo "It's eating ".$food;

    }

}

//实例化一个“人”类

$people = new Human();

$people->eat('rice');

 

//实例化一个“动物”类

$monkey = new Animal();

$monkey->eat('banana');

 

//输出结果:I'm eating rice

// It's eating banana

 

?>

2.8、多态:比如接口A有两个实现B和C,B和C对A接口里面定义的方法实现可以是不同的,这种现象称之为多态;
上述实例中,ICanEat接口定义了一个eat()方法,人类吃米饭,猴子吃香蕉。他们都实现了一个“吃”的方法,但他们吃东西有不同的行为,称之为多态;

2.9、抽象类:介入接口与类的定义之间,允许类里面一部分方法不实现,实现一部分有相同功能且不会更改的方法。然而接口类里面不允许有任何实现的方法。
例如:人和动物都具有吃饭与呼吸的方法,除吃饭不同以外,呼吸方法是相同的,此时需要定义一个抽象类来实现。
定义抽象类关键字:abstract

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
//定义一个抽象类,里面有吃饭和呼吸的方法。呼吸方法需要在抽象类中具体实现

abstract class ICanEat

{

    abstract function eat($food);

    public function breath()

    {

        echo 'Breath use the air...';

    }

}

class Human extends ICanEat

{

    public function eat($food)

    {

        echo "I'm eating ".$food;

        $this->breath();

    }

}

//实例化“人”类

$people = new Human();

$people->eat('rice');

//输出结果:I'm eating rice Breath use the air...

?>

三、PHP面向对象编程特殊实践

PHP语言特定的一些魔术方法:

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
class Object

{

    public function __construct()

    {

        echo "当类在被实例化的时候,自动执行该函数";

    }

    public function __toString()

    {

        return "当对象被当作字符串形式输出时,自动执行该函数";

    }

    public function __invoke($value)

    {

        echo "当对象被当作函数调用时,自动执行该函数".$value;

    }

    /*

    *    当对象访问不存在的方法时,自动执行该函数。也称之为“方法重载”

    *    $fun : 方法名称

    *    $param : 传递的参数

    */

    public function __call($fun,$param)

    {

        echo "调用".$fun."方法不存在,传递的参数".implode(',',$param);

    }

    /*

    *    当对象访问不存在的静态方法时,自动执行该函数。

    *    $fun : 方法名称

    *    $param : 传递的参数

    */

    static function __callStatic($fun,$param)

    {

        echo "调用".$fun."静态方法不存在,传递的参数".implode(',',$param);

    }

    public function __get($key)

    {

        echo "当读取对象中不可访问(未定义)的属性值时,自动调用该函数。".$key."属性不可访问或未定义";

    }

    public function __set($key,$value)

    {

         echo "当给对象中不可访问(未定义)的属性赋值时,自动调用该函数。".$key."属性不可访问或未定义,值".$value;

    }

    public function __isset($key)

    {

        echo "判断对象中的属性不存在时,自动执行该函数。属性:".$key."值未定义";

    }

    public function __unset($key)

    {

        echo "释放对象中的不存在的属性值时,自动执行该函数。属性:".$key."值未定义";

    }

    public function __clone()

    {

        echo "当对象被克隆时,自动执行该函数。";

    }

    public function __destruct()

    {

        echo "当对象执行完成后,自动执行该函数";

    }

}

$obj = new Object();    //实例化对象时,调用__construct()方法

echo $obj;              //将对象以字符串形式输出时,调用__toString()方法

$obj(123);              //当对象以函数形式调用时,执行__invoke()方法

$obj->runTest();        //当调用对象中不存在的方法时,执行__call()方法

$obj::runTest();        //当调用对象中不存在的静态方法时,执行__callStatic()方法

$obj->name;             //当调用对象中不存在的成员属性时,执行__get()方法

$obj->name = "张三";    //当给对象中不存在的成员属性赋值时,执行__set()方法

isset($obj->name) ? 1 : 0;     //判断对象中不存在的成员属性时,执行__isset()方法

unset($obj->name);      //释放对象中的不存在的属性值时,执行__unset()方法

$obj2 = clone $obj;     //当对象被克隆时,执行__clone()方法

                        //对象执行完毕,执行__destruct()方法

?>

转载请保留本文链接:https://www.zhe94.com/765.html

小超越
热爱折腾,曾想着改变世界,如今只能向生活低头,寻找可口的牛奶和面包
添加站长微信作者头像
专注高品质湛江网站建设及湛江SEO优化服务 立即咨询