本文目标

掌握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. //定义 “人” 类 
4.  
5. class Human{ 
6.  
7.     public $name = "";//姓名  
8.  
9.     public $height = "";//身高 
10.  
11.     public $weight = "";//体重 
12.  
13.  
14.  
15.     public function eat($food){ 
16.  
17.         echo $this->name."在吃".$food."<br/>"; 
18.  
19.     } 
20.  
21. } 
22.  
23. //女主播 
24.  
25. class Anchors extends Human{ 
26.  
27.     public $name = ""; 
28.  
29.     public $stageName = ""; 
30.  
31.     public function __construct( $name,$stageName ){ 
32.  
33.         $this->name = $name; 
34.  
35.         $this->stageName = $stageName; 
36.  
37.     } 
38.  
39.     public function singing(){ 
40.  
41.         echo "我是女主播，我会唱歌<br/>"; 
42.  
43.     } 
44.  
45.     
46.  
47. } 
48.  
49. // Nba球员类 
50.  
51.  class NbaPlayer extends Human{ 
52.  
53.    //因为父类已经有了，所以就不需要再写了，通过extends来实现 
54.  
55.     // public $name  = "";//姓名 
56.  
57.     // public $height = "";//身高 
58.  
59.     // public $weight = "";//体重 
60.  
61.  
62.  
63.     public $team = "";//团队 
64.  
65.     public $playerName = "";//球员号码 
66.  
67.  
68.  
69.     public function __construct( $name,$height,$weight,$team,$playerName ){ 
70.  
71.         $this->name = $name; 
72.  
73.         $this->height=$height; 
74.  
75.         $this->weight = $weight; 
76.  
77.         $this->team = $team; 
78.  
79.         $this->playName = $playerName; 
80.  
81.         echo "构造函数执行了,当前对象是{$this->name}<br/>"; 
82.  
83.     } 
84.  
85.       
86.  
87.      
88.  
89.    //跑步 
90.  
91.     public function run(){ 
92.  
93.         echo "跑步中<br/>"; 
94.  
95.     } 
96.  
97.     //跳跃 
98.  
99.     public function jump(){ 
100.  
101.         echo "跳跃<br/>"; 
102.  
103.     } 
104.  
105.     //运球 
106.  
107.     public function dribble(){ 
108.  
109.         echo "运球<br/>"; 
110.  
111.     }  
112.  
113.     //传球 
114.  
115.     public function pass(){ 
116.  
117.         echo "传球<br/>"; 
118.  
119.     } 
120.  
121.     //投篮 
122.  
123.     public function shoot(){ 
124.  
125.         echo "投篮<br/>"; 
126.  
127.     } 
128.  
129.     //扣篮 
130.  
131.     public function dunk(){ 
132.  
133.         echo "扣篮<br/>"; 
134.  
135.     } 
136.  
137.  } 
138.  
139.  
140.  
141.  //数据访问测试 
142.  
143. //public 测试 
144.  
145. //1、测试在类的外部可以访问 
146.  
147.  //创建乔丹对象 
148.  
149.  $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23"); 
150.  
151.  //输出乔丹对象 
152.  
153.  echo "名称= ".$jordon->name."<br/>";//结果能够输出来，说明在外部是可以访问Public类成员的 
154.  
155.  
156.  
157. //2、测试在类的自身里面可以访问 
158.  
159. //例子：比如构造函数里，我们可以直接通过$this->team 
160.  
161.  
162.  
163. //3、测试是否可以子类中可以访问 
164.  
165. //例子：比如父类中定义的name 一样可以在子类（NbaPlayer）的构造函数中直接访问 
166.  
167.  
168.  
169. ?> 

运行效果如下：

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

1. <?php 
2.  
3. //定义“人”类 
4.  
5. class Human{ 
6.  
7.     public $name = "";//姓名 
8.  
9.     public $height = "";//身高 
10.  
11.     public $weight = "";//体重 
12.  
13.  
14.  
15.     protected $addr = "长沙";//受保护的类 
16.  
17.      
18.  
19.     public function eat($food){ 
20.  
21.         echo $this->name."在吃".$food."<br/>"; 
22.  
23.     } 
24.  
25.     //测试protected类成员是否可以在自身类中可以访问 
26.  
27.     public function getAddrInHuman(){ 
28.  
29.         echo "Human 自身类中的add=".$this->addr."<br/>"; 
30.  
31.     } 
32.  
33. } 
34.  
35. //女主播 
36.  
37. class Anchors extends Human{ 
38.  
39.     public $name = ""; 
40.  
41.     public $stageName = ""; 
42.  
43.     public function __construct( $name,$stageName ){ 
44.  
45.         $this->name = $name; 
46.  
47.         $this->stageName = $stageName; 
48.  
49.     } 
50.  
51.     public function singing(){ 
52.  
53.         echo "我是女主播，我会唱歌<br/>"; 
54.  
55.     } 
56.  
57.     //重写方法eat 
58.  
59.     public function  eat($food){ 
60.  
61.         echo "我是女主播，我是边唱歌边吃{$food}<br/>"; 
62.  
63.     } 
64.  
65. } 
66.  
67.  class NbaPlayer extends Human{ 
68.  
69.    //因为父类已经有了，所以就不需要再写了，通过extends来实现 
70.  
71.     // public $name  = "";//姓名 
72.  
73.     // public $height = "";//身高 
74.  
75.     // public $weight = "";//体重 
76.  
77.  
78.  
79.     public $team = "";//团队 
80.  
81.     public $playerName = "";//球员号码 
82.  
83.  
84.  
85.     public function __construct( $name,$height,$weight,$team,$playerName ){ 
86.  
87.         $this->name = $name; 
88.  
89.         $this->height=$height; 
90.  
91.         $this->weight = $weight; 
92.  
93.         $this->team = $team; 
94.  
95.         $this->playName = $playerName; 
96.  
97.         echo "构造函数执行了,当前对象是{$this->name}<br/>"; 
98.  
99.     } 
100.  
101.       
102.  
103.     //测试protected类成员是否可以在子类中可以访问 
104.  
105.     public function getAddrInNbaPlayer(){ 
106.  
107.         echo "在NbaPlayer子类中addr=".$this->addr."<br/>"; 
108.  
109.     } 
110.  
111.  } 
112.  
113.  
114.  
115.  //创建乔丹对象 
116.  
117.  $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23"); 
118.  
119.  
120.  
121.  //数据访问测试 
122.  
123.  //protected测试 
124.  
125.  //1、测试是否可以在自身类中可以访问 
126.  
127.  $jordon->getAddrInHuman();//结果OK，确实是可以访问 
128.  
129.  //2.测试是否可以在子类中访问 
130.  
131.  $jordon->getAddrInNbaPlayer();//结果OK，确实也是可以访问 
132.  
133.  //3.测试是否可以被外部访问 
134.  
135.  echo "在类外部访问addr=".$jordon->addr."<br/>";//结果报错，说明不行 
136.  
137.  
138.  
139. ?> 

运行效果如下：

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

1. <?php 
2.  
3. //定义“人”类 
4.  
5. class Human{ 
6.  
7.     public $name = "";//姓名 
8.  
9.     public $height = "";//身高 
10.  
11.     public $weight = "";//体重 
12.  
13.  
14.  
15.     private $isHungry = true;//测试私有变量是否可以在子类中访问 
16.  
17.     
18.  
19.     //为了让外部可以访问private类成员 
20.  
21.     public function getPrivateInfo(){ 
22.  
23.         return "private 变量 isHungry=".$this->isHungry."<br/>"; 
24.  
25.     } 
26.  
27. } 
28.  
29. //女主播 
30.  
31. class Anchors extends Human{ 
32.  
33.     public $name = ""; 
34.  
35.     public $stageName = ""; 
36.  
37.     public function __construct( $name,$stageName ){ 
38.  
39.         $this->name = $name; 
40.  
41.         $this->stageName = $stageName; 
42.  
43.     } 
44.  
45.     public function singing(){ 
46.  
47.         echo "我是女主播，我会唱歌<br/>"; 
48.  
49.     } 
50.  
51.     //重写方法eat 
52.  
53.     public function  eat($food){ 
54.  
55.         echo "我是女主播，我是边唱歌边吃{$food}<br/>"; 
56.  
57.     } 
58.  
59. } 
60.  
61.  class NbaPlayer extends Human{ 
62.  
63.    //因为父类已经有了，所以就不需要再写了，通过extends来实现 
64.  
65.     // public $name  = "";//姓名 
66.  
67.     // public $height = "";//身高 
68.  
69.     // public $weight = "";//体重 
70.  
71.  
72.  
73.     public $team = "";//团队 
74.  
75.     public $playerName = "";//球员号码 
76.  
77.  
78.  
79.     public function __construct( $name,$height,$weight,$team,$playerName ){ 
80.  
81.         $this->name = $name; 
82.  
83.         $this->height=$height; 
84.  
85.         $this->weight = $weight; 
86.  
87.         $this->team = $team; 
88.  
89.         $this->playName = $playerName; 
90.  
91.         // echo "构造函数执行了,当前对象是{$this->name}<br/>"; 
92.  
93.     } 
94.  
95.     //测试private类成员是否可以在子类中访问 
96.  
97.     public function getIsHungryInNbaPlayer(){ 
98.  
99.         echo "在NbaPlayer子类中isHungry=".$this->isHungry."<br/>"; 
100.  
101.     } 
102.  
103.  } 
104.  
105.    
106.  
107.  //创建乔丹对象 
108.  
109.  $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23"); 
110.  
111.  
112.  
113.  //数据访问测试 
114.  
115.  //private测试 
116.  
117.  //1.测试私有变量能否被外部访问 
118.  
119.  echo "私有变量isHungry =".$jordon->isHungry ."<br/>";//结果不能访问，说明private变量不能被子类访问 
120.  
121.  //测试私有变量能否在定义的类的内部访问 
122.  
123.  echo $jordon->getPrivateInfo();//结果Ok，说明可以  
124.  
125. //测试私有变量是否可以在子类中访问 
126.  
127. $jordon->getIsHungryInNbaPlayer();//结果报错，说明也不能在子类中访问 
128.  
129.  
130.  
131. ?> 

运行效果如下：

总结：

1、Public:公有的类成员

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

● 定义该类的类(自身)

● 该类的子类

● 其他类

2、Protected:受保护的类成员

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

3、Private:私有的类成员

● 只有自身才可以访问

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

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

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

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

答案揭晓：

代码如下：

1. <?php 
2.  
3. class Human{ 
4.  
5.     public $name = "";//姓名 
6.  
7.     public $height = "";//身高 
8.  
9.     public $weight = "";//体重 
10.  
11.  
12.  
13. } 
14.  
15. //女主播 
16.  
17. class Anchors extends Human{ 
18.  
19.     public $name = ""; 
20.  
21.     public $stageName = ""; 
22.  
23.     public function __construct( $name,$stageName ){ 
24.  
25.         $this->name = $name; 
26.  
27.         $this->stageName = $stageName; 
28.  
29.     } 
30.  
31.     public function singing(){ 
32.  
33.         echo "我是女主播，我会唱歌<br/>"; 
34.  
35.     } 
36.  
37.     //重写方法eat 
38.  
39.     public function  eat($food){ 
40.  
41.         echo "我是女主播，我是边唱歌边吃{$food}<br/>"; 
42.  
43.     } 
44.  
45. } 
46.  
47.  class NbaPlayer extends Human{ 
48.  
49.    //因为父类已经有了，所以就不需要再写了，通过extends来实现 
50.  
51.     // public $name  = "";//姓名 
52.  
53.     // public $height = "";//身高 
54.  
55.     // public $weight = "";//体重 
56.  
57.  
58.  
59.     public $team = "";//团队 
60.  
61.     public $playerName = "";//球员号码 
62.  
63.  
64.  
65.      //数据访问 
66.  
67.      private $age = "40"; 
68.  
69.      //end 
70.  
71.  
72.  
73.     public function __construct( $name,$height,$weight,$team,$playerName ){ 
74.  
75.         $this->name = $name; 
76.  
77.         $this->height=$height; 
78.  
79.         $this->weight = $weight; 
80.  
81.         $this->team = $team; 
82.  
83.         $this->playName = $playerName; 
84.  
85.         echo "构造函数执行了,当前对象是{$this->name}<br/>"; 
86.  
87.     } 
88.  
89.       
90.  
91.      
92.  
93.    //跑步 
94.  
95.     public function run(){ 
96.  
97.         echo "跑步中<br/>"; 
98.  
99.     } 
100.  
101.     //跳跃 
102.  
103.     public function jump(){ 
104.  
105.         echo "跳跃<br/>"; 
106.  
107.     } 
108.  
109.     //运球 
110.  
111.     public function dribble(){ 
112.  
113.         echo "运球<br/>"; 
114.  
115.     }  
116.  
117.     //传球 
118.  
119.     public function pass(){ 
120.  
121.         echo "传球<br/>"; 
122.  
123.     } 
124.  
125.     //投篮 
126.  
127.     public function shoot(){ 
128.  
129.         echo "投篮<br/>"; 
130.  
131.     } 
132.  
133.     //扣篮 
134.  
135.     public function dunk(){ 
136.  
137.         echo "扣篮<br/>"; 
138.  
139.     } 
140.  
141.     
142.  
143.     //数据访问  
144.  
145.     public function getAge(){ 
146.  
147.         // echo $this->name."的age=".$this->age."<br/>"; 
148.  
149.         //既然能够在自身类中获取到年龄，那么为了解决NBA球员不想让别人知道自己真实年龄的问题 
150.  
151.             //我们就可以对年龄进行操作-造假 让年龄更小 
152.  
153.         $age = $this->age-2; 
154.  
155.         echo $this->name."的age=".$age."<br/>"; 
156.  
157.     } 
158.  
159.  } 
160.  
161.    
162.  
163.  //创建乔丹对象 
164.  
165.  $jordon = new NbaPlayer("乔丹","1.98米","98公斤","公牛","23"); 
166.  
167.  $jordon->getAge();//结果Ok 说明年龄是可以获取到的，既然可以获取到age我们在函数内部作假，来达到一个谎报年龄的目的 
168.  
169. ?> 
170.  

运行效果如下：

总结：

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

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

Tags: PHP面向对象 PHP数据访问

分享到：