本文目标

掌握PHP中数据访问的3种方式的定义和作用

1、public

2、protected

3、private

(一)、数据访问的3种方式

1、Public:公有的类成员

可以在任何地方访问,具体可以被哪些访问了：

● 定义该类的类(自身)

● 该类的子类

● 其他类

2、Protected:受保护的类成员

● 定义该类的类(自身)

● 该类的子类

3、Private:私有的类成员

● 只有自身才可以访问

总结：从上到下约束能力是越来越强的

单纯从以上的文字描述，我们理解起来还是有点费力的，那么还是按照理论+实践的方式来进行理解，那么接下来我们就通过具体的代码来理解这3种数据访问的方式在PHP中到底是如何实现的，到底它们各自的特点是什么，最后来体会一下它们的约束能力到底又是怎样。

（二）具体代码

说明：为了让大家能更好的理解面向对象，所以写文章的时候，我也是尽量遵循一定的规则，由浅到深，由易到难，所以我写的每篇文章都是和上篇文章有一定的关联，比如以下的代码案例，我又是在上篇文章的代码上进行的拓展和延伸。

案例一：知道public的定义，然后证明它可以在3个地方都可以访问（1.在自己定义的类中，2.在子类中 3.在外部）。

1. <?php
2. //定义 “人” 类
3. class Human{
4. public $name = "";//姓名
5. public $height = "";//身高
6. public $weight = "";//体重
7. public function eat($food){
8. echo $this->name."在吃".$food."<br/>";
9. }
10. }
11. //女主播
12. class Anchors extends Human{
13. public $name = "";
14. public $stageName = "";
15. public function __construct( $name,$stageName ){
16. $this->name = $name;
17. $this->stageName = $stageName;
18. }
19. public function singing(){
20. echo "我是女主播，我会唱歌<br/>";
21. }
22. }
23. // Nba球员类
24. class NbaPlayer extends Human{
25. //因为父类已经有了，所以就不需要再写了，通过extends来实现
26. // public $name = "";//姓名
27. // public $height = "";//身高
28. // public $weight = "";//体重
29. public $team = "";//团队
30. public $playerName = "";//球员号码
31. public function __construct( $name,$height,$weight,$team,$playerName ){
32. $this->name = $name;
33. $this->height=$height;
34. $this->weight = $weight;
35. $this->team = $team;
36. $this->playName = $playerName;
37. echo "构造函数执行了,当前对象是{$this->name}<br/>";
38. }
39. //跑步
40. public function run(){
41. echo "跑步中<br/>";
42. }
43. //跳跃
44. public function jump(){
45. echo "跳跃<br/>";
46. }
47. //运球
48. public function dribble(){
49. echo "运球<br/>";
50. }
51. //传球
52. public function pass(){
53. echo "传球<br/>";
54. }
55. //投篮
56. public function shoot(){
57. echo "投篮<br/>";
58. }
59. //扣篮
60. public function dunk(){
61. echo "扣篮<br/>";
62. }
63. }
64. //数据访问测试
65. //public 测试
66. //1、测试在类的外部可以访问
67. //创建乔丹对象
68. $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
69. //输出乔丹对象
70. echo "名称= ".$jordon->name."<br/>";//结果能够输出来，说明在外部是可以访问Public类成员的
71. //2、测试在类的自身里面可以访问
72. //例子：比如构造函数里，我们可以直接通过$this->team
73. //3、测试是否可以子类中可以访问
74. //例子：比如父类中定义的name 一样可以在子类（NbaPlayer）的构造函数中直接访问
75. ?>

运行效果如下：

案例二：知道protected的定义，然后证明它可以在2个地方都可以访问（1.在自己定义的类中，2.在子类中 ）

1. <?php
2. //定义“人”类
3. class Human{
4. public $name = "";//姓名
5. public $height = "";//身高
6. public $weight = "";//体重
7. protected $addr = "长沙";//受保护的类
8. public function eat($food){
9. echo $this->name."在吃".$food."<br/>";
10. }
11. //测试protected类成员是否可以在自身类中可以访问
12. public function getAddrInHuman(){
13. echo "Human 自身类中的add=".$this->addr."<br/>";
14. }
15. }
16. //女主播
17. class Anchors extends Human{
18. public $name = "";
19. public $stageName = "";
20. public function __construct( $name,$stageName ){
21. $this->name = $name;
22. $this->stageName = $stageName;
23. }
24. public function singing(){
25. echo "我是女主播，我会唱歌<br/>";
26. }
27. //重写方法eat
28. public function eat($food){
29. echo "我是女主播，我是边唱歌边吃{$food}<br/>";
30. }
31. }
32. class NbaPlayer extends Human{
33. //因为父类已经有了，所以就不需要再写了，通过extends来实现
34. // public $name = "";//姓名
35. // public $height = "";//身高
36. // public $weight = "";//体重
37. public $team = "";//团队
38. public $playerName = "";//球员号码
39. public function __construct( $name,$height,$weight,$team,$playerName ){
40. $this->name = $name;
41. $this->height=$height;
42. $this->weight = $weight;
43. $this->team = $team;
44. $this->playName = $playerName;
45. echo "构造函数执行了,当前对象是{$this->name}<br/>";
46. }
47. //测试protected类成员是否可以在子类中可以访问
48. public function getAddrInNbaPlayer(){
49. echo "在NbaPlayer子类中addr=".$this->addr."<br/>";
50. }
51. }
52. //创建乔丹对象
53. $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
54. //数据访问测试
55. //protected测试
56. //1、测试是否可以在自身类中可以访问
57. $jordon->getAddrInHuman();//结果OK，确实是可以访问
58. //2.测试是否可以在子类中访问
59. $jordon->getAddrInNbaPlayer();//结果OK，确实也是可以访问
60. //3.测试是否可以被外部访问
61. echo "在类外部访问addr=".$jordon->addr."<br/>";//结果报错，说明不行
62. ?>

运行效果如下：

案例三：知道private的定义，然后证明它只能在1个地方可以访问（1.在自己定义的类中）

1. <?php
2. //定义“人”类
3. class Human{
4. public $name = "";//姓名
5. public $height = "";//身高
6. public $weight = "";//体重
7. private $isHungry = true;//测试私有变量是否可以在子类中访问
8. //为了让外部可以访问private类成员
9. public function getPrivateInfo(){
10. return "private 变量 isHungry=".$this->isHungry."<br/>";
11. }
12. }
13. //女主播
14. class Anchors extends Human{
15. public $name = "";
16. public $stageName = "";
17. public function __construct( $name,$stageName ){
18. $this->name = $name;
19. $this->stageName = $stageName;
20. }
21. public function singing(){
22. echo "我是女主播，我会唱歌<br/>";
23. }
24. //重写方法eat
25. public function eat($food){
26. echo "我是女主播，我是边唱歌边吃{$food}<br/>";
27. }
28. }
29. class NbaPlayer extends Human{
30. //因为父类已经有了，所以就不需要再写了，通过extends来实现
31. // public $name = "";//姓名
32. // public $height = "";//身高
33. // public $weight = "";//体重
34. public $team = "";//团队
35. public $playerName = "";//球员号码
36. public function __construct( $name,$height,$weight,$team,$playerName ){
37. $this->name = $name;
38. $this->height=$height;
39. $this->weight = $weight;
40. $this->team = $team;
41. $this->playName = $playerName;
42. // echo "构造函数执行了,当前对象是{$this->name}<br/>";
43. }
44. //测试private类成员是否可以在子类中访问
45. public function getIsHungryInNbaPlayer(){
46. echo "在NbaPlayer子类中isHungry=".$this->isHungry."<br/>";
47. }
48. }
49. //创建乔丹对象
50. $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
51. //数据访问测试
52. //private测试
53. //1.测试私有变量能否被外部访问
54. echo "私有变量isHungry =".$jordon->isHungry ."<br/>";//结果不能访问，说明private变量不能被子类访问
55. //测试私有变量能否在定义的类的内部访问
56. echo $jordon->getPrivateInfo();//结果Ok，说明可以
57. //测试私有变量是否可以在子类中访问
58. $jordon->getIsHungryInNbaPlayer();//结果报错，说明也不能在子类中访问
59. ?>

运行效果如下：

总结：

1、Public:公有的类成员

可以在任何地方访问,具体可以被哪些访问了：

● 定义该类的类(自身)

● 该类的子类

● 其他类

2、Protected:受保护的类成员

● 可以被其自身及其子类访问

3、Private:私有的类成员

● 只有自身才可以访问

4.为了让外部可以访问private类成员，我们可以通过在类中定义一个public方法，然后在public方法中返回private类成员

好，到了这里，想必大家对数据访问应该有了一个比较清晰的认识，那我们现在来学以致用，用我们学到的这个知识来解决以下的问题，先自己思考一下怎么做，然后再看答案

问题：NBA球员一般都不想让其他人知道自己的真实姓名，比如说我明明是40岁，但是我就想让别人以为是38岁

思考中.......................

答案揭晓：

代码如下：

1. <?php
2. class Human{
3. public $name = "";//姓名
4. public $height = "";//身高
5. public $weight = "";//体重
6. }
7. //女主播
8. class Anchors extends Human{
9. public $name = "";
10. public $stageName = "";
11. public function __construct( $name,$stageName ){
12. $this->name = $name;
13. $this->stageName = $stageName;
14. }
15. public function singing(){
16. echo "我是女主播，我会唱歌<br/>";
17. }
18. //重写方法eat
19. public function eat($food){
20. echo "我是女主播，我是边唱歌边吃{$food}<br/>";
21. }
22. }
23. class NbaPlayer extends Human{
24. //因为父类已经有了，所以就不需要再写了，通过extends来实现
25. // public $name = "";//姓名
26. // public $height = "";//身高
27. // public $weight = "";//体重
28. public $team = "";//团队
29. public $playerName = "";//球员号码
30. //数据访问
31. private $age = "40";
32. //end
33. public function __construct( $name,$height,$weight,$team,$playerName ){
34. $this->name = $name;
35. $this->height=$height;
36. $this->weight = $weight;
37. $this->team = $team;
38. $this->playName = $playerName;
39. echo "构造函数执行了,当前对象是{$this->name}<br/>";
40. }
41. //跑步
42. public function run(){
43. echo "跑步中<br/>";
44. }
45. //跳跃
46. public function jump(){
47. echo "跳跃<br/>";
48. }
49. //运球
50. public function dribble(){
51. echo "运球<br/>";
52. }
53. //传球
54. public function pass(){
55. echo "传球<br/>";
56. }
57. //投篮
58. public function shoot(){
59. echo "投篮<br/>";
60. }
61. //扣篮
62. public function dunk(){
63. echo "扣篮<br/>";
64. }
65. //数据访问
66. public function getAge(){
67. // echo $this->name."的age=".$this->age."<br/>";
68. //既然能够在自身类中获取到年龄，那么为了解决NBA球员不想让别人知道自己真实年龄的问题
69. //我们就可以对年龄进行操作-造假 让年龄更小
70. $age = $this->age-2;
71. echo $this->name."的age=".$age."<br/>";
72. }
73. }
74. //创建乔丹对象
75. $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23");
76. $jordon->getAge();//结果Ok 说明年龄是可以获取到的，既然可以获取到age我们在函数内部作假，来达到一个谎报年龄的目的
77. ?>

运行效果如下：

总结：

1.知道了在PHP中数据访问有三种形式，public,protected,private

2.知道了3种数据访问方式各自的特点