PHP面向对象3之特性-封装

封装：隐藏对象的字段和实现细节，仅对外公开接口,控制在程序中字段的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成 一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。

 1 <?php
 2 /**
 3  * PHP面向对象特性 --封装 
 4  *         隐藏对象的字段和实现细节，仅对外公开接口，控制在程序中字段的读和修改的访问级别；
 5  * 将抽象得到的数据和行为(或功能)相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，
 6  * 形成“类”，其中数据和函数都是类的成员。
 7  * 字段的作用域 
 8  *         1、public 公有的(类外可以访问) 
 9  *         2、private 私有的(类内访问)
10  *         3、protected 受保护的(类内和子类可以访问，类外无法访问)
11  */
12 class Computer {
13     // 类内：创建类的花括号内，其他则是类外
14     public $_name;
15 }
16 
17 $computer1 = new Computer ();
18 $computer1->_name = 'dell';
19 echo $computer1->_name;
20 ?>

 

 1 <?php
 2 /**
 3  * PHP面向对象特性 --封装 
 4  *         private 私有字段如何调用
 5 */
 6 // 创建一个computer的类，里面一个私有的字段
 7 class Computer {
 8     // private是私有的，内外不能够被调用
 9     private $_name = '联想';
10     // 通过一个公共方法作为入口，访问私有字段，必须使用$this关键字
11     function _run() {
12         //字段在类内调用的时候，必须是类->字段，而$_name只是一个普通变量而已
13         //echo $_name;
14         //字段在类内调用的方法是对象->字段，而类必须是Computer->_name
15         //可以用$this代替类名，如下：
16         echo $this->_name;
17     }
18 }
19 $computer1 = new Computer ();
20 echo $computer1->_run ();
21 ?>

 

 1 <?php
 2 /**
 3  * PHP面向对象特性 --封装  
 4  *         private 私有字段赋值取值
 5 */
 6 class Computer{
 7     private $_name;
 8     //必须写个对外的入口，才可以取到值
 9     public function getName() {
10         return $this->_name;
11     }
12     //必须写一个对内的入口，对私有字段进行赋值
13     public function setName($_name){
14         return $this->_name=$_name;
15     }
16 }
17 $computer1 = new Computer();
18 echo $computer1->setName('哈哈');
19 echo $computer1->getName();
20 ?>

方法私有： 有些使用类里面的方法并不需要对外公开， 只是里面运作的一部分， 这个时候可以将方法也封装起来。

 1 <?php
 2 /**
 3  * PHP面向对象特性 --封装
 4 *         如果有10个字段，那么就必须要20个方法才能赋值取值
 5 *         方便的方法：PHP内置两个方法(拦截器)专门用来取值与赋值：__set(), __get()
 6 */
 7 class Computer{
 8     private $_name;
 9     private $_model;
10     private $_cpu;
11     
12     //当类外的对象直接调用私有字段时，会跟着去检查是否有拦截器方法
13     //如果直接对私有字段进行赋值，那么__set方法就会拦截住，就不会报错
14     
15     /*
16      * __set() 和 __get()方法私有了还可以执行，是因为目前程序的指针已经在类内了，
17      * 而类内可以执行封装的方法，类内执行私有方法，不会出现错误
18      * 它们直接私有化也能执行，也可以防止被恶意调用。
19      */
20     
21     //采用拦截器方法进行赋值
22     private function __set($_key,$_value){
23         //如果：$_key='_name',$_value='dell'    那么：$this->_name='dell';
24         //如果：$_key='_model',$_value='i7'        那么：$this->_mode='i7';
25         $this->$_key=$_value;
26     }
27     //采用拦截器方法进行取值
28     private function __get($_key){
29         //如果$_key='_name'    那么$this->_name
30         //......
31         return $this->$_key;
32     }
33     
34 }
35 
36 $computer1 = new Computer();
37 $computer1->_name='dell';
38 $computer1->_model='i7';
39 $computer1->_cpu='四核';
40     echo '型号:'.$computer1->_name.$computer1->_model.$computer1->_cpu;
41 ?>

建议： 方法前面如果没有修饰符， 那么就是外部可访问的公共方法， 但为了让程序更加的清晰，建议在前面加上public。

<?php
/**
 * PHP面向对象特性 --封装 --常量(constant)
 *         在类中可以定义常量，用来表示不会改变的值，对于从该类实例化的任何对象来说，
 *     常量值在这些对象的整个生命周期中都保持不变。
*/
class Computer{
    const NAME = 'DELL';
}
//常量的输出方法：类::

echo Computer::NAME;

?>

 

 1 <?php
 2 /**
 3  * PHP面向对象特性 --封装 --静态类成员---静态字段
 4  *         有时候，可能需要创建供所有类实例共享的字段和方法，这些字段和方法与所有的类实例有关
 5  * 但不能由任何特定对象调用
 6 */
 7 class Computer{
 8     public static $_count =0;
 9     public function _add() {
10         //$this->_count++;//累加1
11         //如果是静态成员，那么就应该用self来调用，而不是$this
12         self::$_count++;
13     }
14 }
15 //累积效果
16 $computer1 = new Computer();
17 $computer1->_add();
18 $computer1->_add();
19 $computer1->_add();
20 echo Computer::$_count;
21 echo '<br />';
22 $computer2 = new Computer();
23 $computer2->_add();
24 $computer2->_add();
25 $computer2->_add();
26 echo Computer::$_count;
27 ?>

 

 1 <?php
 2 /**
 3  * PHP面向对象特性--封装 --静态类成员---静态方法
 4 */
 5 class Computer{
 6     public static $_count=0;
 7     public static function _run(){
 8         self::$_count++;
 9     }
10 }
11 
12 Computer::_run();
13 Computer::_run();
14 Computer::_run();
15 echo Computer::$_count;
16 ?>

 

 1 <?php
 2 /**
 3  * PHP面向对象特性--封装 --instanceof关键字
 4  *         PHP5有一个instanceof关键字，使用这个关键字可以确定一个对象是类的实例、类的子类
 5  * 还是实现了某个特定的接口，并进行相应的操作
 6  */
 7 class Computer{
 8     
 9 }
10 
11 $computer1 = new Computer();
12 echo ($computer1 instanceof Computer);
13 ?>

 

转载于:https://www.cnblogs.com/im404/articles/PHP_OOP3.html