PHP 类与对象全解析（二)

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› PHP›PHP编程经验

原作者: [db:作者] 来自: [db:来源] 收藏邀请

7.Static关键字

声明类成员或方法为static，就可以不实例化类而直接访问。不能通过一个对象来访问其中的静态成员（静态方法除外）。

静态成员属于类，不属于任何对象实例，但类的对象实例都能共享。
小结:

在类内部访问静态成员属性或者方法，使用 self::（没有 $ 符号），如：
self:: $country //类内部访问静态成员属性
self:: myCountry()
在子类访问父类静态成员属性或方法，使用 parent::（没有 $ 符号），如：
parent:: $country
parent:: myCountry()
外部访问静态成员属性和方法为类名/子类名:: ，如：
Person::$country
Person::myCountry()
Student::$country
但静态方法也可以通过普通对象的方式访问

    <?php  
      
    Class Person{  
        // 定义静态成员属性  
        public static $country = "中国";  
        // 定义静态成员方法  
        public static function myCountry() {  
            // 内部访问静态成员属性  
            echo "我是".self::$country."人<br />";  
        }  
    }  
    class Student extends Person {  
        function study() {  
            echo "我是". parent::$country."人<br />";  
        }  
    }  
    // 输出成员属性值  
    echo Person::$country."<br />";     // 输出：中国  
    $p1 = new Person();  
    //echo $p1->country;            // 错误写法  
    // 访问静态成员方法  
    Person::myCountry();            // 输出：我是中国人  
    // 静态方法也可通过对象访问：  
    $p1->myCountry();  
      
    // 子类中输出成员属性值  
    echo Student::$country."<br />";    // 输出：中国  
    $t1 = new Student();  
    $t1->study();           // 输出：我是中国人  
      
    ?>

---------------------------------------------------

8.抽象类 PHP5支持抽象类和抽象方法。

      抽象类不能直接被实例化，你必须先继承该抽象类，然后再实例化子类。
      抽象类中至少要包含一个抽象方法。如果类方法被声明为抽象的，那么其中就不能包括具体的功能实现。
      继承一个抽象类的时候，子类必须实现抽象类中的所有抽象方法；
      另外，这些方法的可见性必须和抽象类中一样（或者更为宽松）。
      如果抽象类中某个抽象方法被声明为protected，那么子类中实现的方法就应该声明为protected或者public，而不能定义为private。
      //抽象方法：abstract protected function getValue();
例子1

    abstract class AbstractClass{  
        // 定义抽象方法  
        abstract protected function getValue();  
        // 普通方法  
        public function printOut(){  
            print $this->getValue()."<br />";  
        }  
    }  
    class ConcreteClass extends AbstractClass{  
        protected function getValue(){  
            return "abstract ";//抽象方法的实现  
        }  
    }  
      
    $class1 = new ConcreteClass;  
    $class1->printOut();

例子2

    abstract class AbstractClass  
    {  
     // 强制要求子类定义这些方法  
        abstract protected function getValue();  
        abstract protected function prefixValue($prefix);  
      
        // 普通方法（非抽象方法）  
        public function printOut() {  
            print $this->getValue() . "\n";  
        }  
    }  
      
    class ConcreteClass1 extends AbstractClass  
    {  
        protected function getValue() {  
            return "ConcreteClass1";  
        }  
      
        public function prefixValue($prefix) {  
            return "{$prefix}ConcreteClass1";  
        }  
    }  
      
    class ConcreteClass2 extends AbstractClass  
    {  
        public function getValue() {  
            return "ConcreteClass2";  
        }  
      
        public function prefixValue($prefix) {  
            return "{$prefix}ConcreteClass2";  
        }  
    }  
      
    $class1 = new ConcreteClass1;  
    $class1->printOut();  
    echo $class1->prefixValue('FOO_') ."\n";  
      
    $class2 = new ConcreteClass2;  
    $class2->printOut();  
    echo $class2->prefixValue('FOO_') ."\n";

/*
* 抽象类不能直接被实例化，你必须先继承该抽象类，然后再实例化子类。
      抽象类中至少要包含一个抽象方法。如果类方法被声明为抽象的，那么其中就不能包括具体的功能实现。
      继承一个抽象类的时候，子类必须实现抽象类中的所有抽象方法；
      另外，这些方法的可见性必须和抽象类中一样（或者更为宽松）。
      如果抽象类中某个抽象方法被声明为protected，那么子类中实现的方法就应该声明为protected或者public，而不能定义为private。
*
*/

    class Person {  
        public $name;  
        public $age;  
      
        function say() {  
            echo "my name is:".$this->name."<br />";  
        echo "my age is:".$this->age;  
        }  
    }

// 类的继承

    class Student extends Person {  
        var $school;    //学生所在学校的属性  
          
        function study() {  
            echo "my name is:".$this->name."<br />";  
            echo "my shool is:".$this->school;  
        }         
    }  
      
    $t1 = new Student();  
    $t1->name = "zhangsan";  
    $t1->school = "beijindaxue";  
    $t1->study();

---------------------------------------------------------------------

9.接口

接口定义：方法和常量值定义的集合
通过interface来定义一个接口，就像定义一个标准的类一样，但其中定义所有的方法都是空的。

接口的特性：接口中定义的所有方法都必须是public

接口的实现：一个接口可以使用implements操作符，类中必须实现接口中的所有方法，否则会报fatal错误，如果要实现多个接口，可以使用逗号来分隔多个接口的名称。

抽象类和接口的区别

接口是特殊的抽象类，也可以看做是一个模型的规范。接口与抽象类大致区别如下：

1.一个子类如果 implements 一个接口，就必须实现接口中的所有方法（不管是否需要）；如果是继承一个抽象类，只需要实现需要的方法即可。
2.如果一个接口中定义的方法名改变了，那么所有实现此接口的子类需要同步更新方法名；而抽象类中如果方法名改变了，其子类对应的方法名将不受影响，只是变成了一个新的方法而已（相对老的方法实现）。
3.抽象类只能单继承，当一个子类需要实现的功能需要继承自多个父类时，就必须使用接口。
实例1：
// 声明一个'iTemplate'接口

nterface iTemplate  
{  
    public function setVariable($name, $var);  
    public function getHtml($template);  
}

// 实现接口
// 下面的写法是正确的

    class Template implements iTemplate  
    {  
        private $vars = array();  
        
        public function setVariable($name, $var)  
        {  
            $this->vars[$name] = $var;  
        }  
        
        public function getHtml($template)  
        {  
            foreach($this->vars as $name => $value) {  
                $template = str_replace('{' . $name . '}', $value, $template);  
            }  
       
            return $template;  
        }  
    }

实例2：
//定义接口

    interface User{  
         function getDiscount();  
         function getUserType();  
     }

//VIP用户接口实现

    class VipUser implements User{  
        // VIP 用户折扣系数  
        private $discount = 0.8;  
        function getDiscount() {  
            return $this->discount;  
        }  
        function getUserType() {  
            return "VIP user";  
        }  
    }  
    class Goods{  
        var $price = 100;  
        var $vc;  
        //定义 User 接口类型参数，这时并不知道是什么用户  
        function run(User $vc){  
            $this->vc = $vc;  
            $discount = $this->vc->getDiscount();  
            $usertype = $this->vc->getUserType();  
            echo $usertype."goods Price:".$this->price*$discount;  
        }  
    }  
      
    display ->run(new VipUser);    //可以是更多其他用户类型

-------------------------------------------------------------

10.重载

   定义：一个类中的方法与另一个方法名称相同，但参数不同
   什么情况下执行重载？当调用当前的环境下未被定义的属性或者方法时，或者当调用当前环境下不可见的属性或方法。

提示:
如果父类定义方法时使用了 final 关键字，则不允许被子类方法覆盖。

访问父类被覆盖的方法
可以通过parent:: 符号来访问父类被覆盖的方法或成员属性：
//PHP 重载方法 __call()

__call()（Method overloading）
为了避免当调用的方法不存在时产生错误，可以使用 __call() 方法来避免。该方法在调用的方法不存在时会自动调用，程序仍会继续执行下去。

语法：
// __call()方法重载

    class Test{  
        public function __call($name,$args){  
         if($name== 'null' && count($args)==2 ){  
          $type='num';  
       foreach($args as $key => $val){  
           if(!(is_int($val) || is_float($val))){  
            $type= 'string';  
        }  
       }  
       $method=$name.ucfirst($type);  
       if(method_exists($this,$method),$args){  
           call_user_func_array(array($this,$method),$args);  
       }  
      }  
     }  
     public addNum($i,$j){  
         echo $i+$j;  
     }  
       
     public addString($i,$j){  
         echo $i.$j;  
     }  
    }  
    $test =new Test();  
    $test->add(3,4);  
    $test->add(3,'4');

案例：

    class MemberTest {  
            
        private $data = array();//被重载的数据保存在此    
        public $declared = 1;/**  重载不能被用在已经定义的属性  */  
        private $hidden = 2; /**  只有从类外部访问这个属性时，重载才会发生 */  
      
        public function __set($name, $value) {  
            echo "Setting '$name' to '$value'\n";  
            $this->data[$name] = $value;  
        }  
      
        public function __get($name) {  
            echo "Getting '$name'\n";  
            if (array_key_exists($name, $this->data)) {  
                return $this->data[$name];  
            }  
      
            $trace = debug_backtrace();  
            trigger_error(  
                'Undefined property via __get(): ' . $name .  
                ' in ' . $trace[0]['file'] .  
                ' on line ' . $trace[0]['line'],  
                E_USER_NOTICE);  
            return null;  
        }  
      
        /**  PHP 5.1.0之后版本 */  
        public function __isset($name) {  
            echo "Is '$name' set?\n";  
            return isset($this->data[$name]);  
        }  
      
        /**  PHP 5.1.0之后版本 */  
        public function __unset($name) {  
            echo "Unsetting '$name'\n";  
            unset($this->data[$name]);  
        }  
      
        /**  非魔术方法  */  
        public function getHidden() {  
            return $this->hidden;  
        }  
    }  
      
      
    echo "<pre>\n";  
      
    $obj = new MemberTest;  
      
    $obj->a = 1;  
    echo $obj->a . "\n\n";  
      
    var_dump(isset($obj->a));  
    unset($obj->a);  
    var_dump(isset($obj->a));  
    echo "\n";  
      
    echo $obj->declared . "\n\n";  
      
    echo "Let's experiment with the private property named 'hidden':\n";  
    echo "Privates are visible inside the class, so __get() not used...\n";  
    echo $obj->getHidden() . "\n";  
    echo "Privates not visible outside of class, so __get() is used...\n";  
    echo $obj->hidden . "\n";

//属性重载：__set(),__get(),__isset(),__unset()

    class Person{  
        private $data =array();  
        function __set($name,$value){  
         $this->data[$name]=$value;  
     }  
     function __get($name){  
         return $this->data[$name];  
     }  
    }

-----------------------------------------------------------------------------------

11.对象迭代

PHP5提供了一种迭代（iteration）对象的功能，就像使用数组那样，可以通过foreach 来遍历对象中的属性

    class MyClass  
    {  
        public $var1 = 'value 1';  
        public $var2 = 'value 2';  
        public $var3 = 'value 3';  
      
        protected $protected = 'protected var';  
        private   $private   = 'private var';  
      
        function iterateVisible() {  
           echo "MyClass::iterateVisible:\n";  
           foreach($this as $key => $value) {  
               print "$key => $value\n";  
           }  
        }  
    }  
      
    $class = new MyClass();  
      
    foreach($class as $key => $value) {  
        print "$key => $value\n";  
    }  
    echo "\n";  
      
      
    $class->iterateVisible();

---------------------------------------------------------------------------

12.设计模式: 工厂模式和单例模式，　观察者模式，命令链模式和策略模式

　命令链模式以松散耦合主题为基础，发送消息、命令和请求，或通过一组处理程序发送任意内容。每个处理程序都会自行判断自己能否处理请求。
如果可以，该请求被处理，进程停止。您可以为系统添加或移除处理程序，而不影响其他处理程序。

工厂模式
定义：工厂模式（Factory）允许你在代码执行时实例化对象。它之所以被称为工厂模式是因为它负责“生产”对象。工厂方法的参数是你要生成的对象对应的类名称。

工厂模式语法：

    <?php  
    class Example  
    {  
        public static function factory($type)  
        {  
            if (include_once 'Drivers/' . $type . '.php') {  
                $classname = 'Driver_' . $type;  
                return new $classname;  
            } else {  
                throw new Exception ('Driver not found');  
            }  
        }  
    }  
    ?>

工厂模式案例：

    <?php  
    interface IUser{  
     function getName();  
    }  
    class User implements IUser{  
     public function __construct($id){}  
     public function getName(){  
         return "haha";  
     }  
    }  
    class UserFactory{  
        public static function Create($id){  
      return new User($id);  
     }  
    }  
    $uo =UserFactory::Create(1);  
    echo $uo->getName();  
      
    ?>

单例
   定义三要素：1，某个类只能有一个实例 2，必须自行创建这个实例 3，必须自行向系统提供这个实例

   作用： 1，如果系统中需要有一个类来全局控制某些配置信息，那么使用单例模式可以很方便的实现。
          2，使用单例模式，可以避免大量的new操作消耗资源（）
          3在一个页面请求中，便于调试，因为所有的代码都集中在一个类中（如数据库操作类）可以在类中设置钩子，输出日志，从而避免到处都是var_dump

单例模式（Singleton）用于为一个类生成一个唯一的对象。最常用的地方是数据库连接。使用单例模式生成一个对象后，该对象可以被其它众多对象所使用。
单件模式是我们在开发中经常用到的一种设计模式，利用PHP5面向对象的特性，我们可以很容易的构建单件模式的应用，下面是单件模式在PHP中的几种实现方法：

    class Stat{  
        static $instance = NULL;  
          
        static function getInstance(){  
            if(self::$instance == NULL){  
                self::$instance = new Stat();  
            }  
              
            return self::$instance;  
        }      
        private function __construct(){  
        }      
        private function __clone(){  
        }      
          
        function sayHi(){  
            return "The Class is saying hi to u ";  
        }  
    }  
      
      
    echo Stat::getInstance()->sayHi();

这是一种最通常的方式，在一个getInstance方法中返回唯一的类实例。

对这里例子稍加修改，便可以产生一个通用的方法，只要叫道任何你想用到单件的类里，就可以了。

    class Teacher{  
        function sayHi(){  
            return "The teacher smiling and said 'Hello '";  
        }  
          
        static function getInstance(){  
            static $instance;  
              
            if(!isset($instance)){  
                $c = __CLASS__;  
                $instance = new $c;  
            }          
            return $instance;  
        }  
    }  
      
    echo Teacher::getInstance()->sayHi();

最后一种是提供一个singleton类，然后通过调用getInstance方法，可以为任何一个类生产出一个实例来。

    class singleton{  
        function getInstance($class){  
            static $instances = array();  
            if(!array_key_exists($class,$instances)){  
                $instances[$class] = &new $class;  
            }  
            $instance = $instances[$class];  
              
            return $instance;  
        }  
    }  
      
    class People{  
        function sayHi(){  
            return 'Hello i am a people?';  
        }  
    }  
      
    echo "<br />";  
    echo singleton::getInstance('People')->sayHi();

通过这三种方法，我们可以很容易的应用单件模式，如果能够结合工厂模式，将使我们的编程变得更有条理和效率。
---------------------------------------------------------------------------------------

鲜花

握手

雷人

路过

鸡蛋

该文章已有0人参与评论

请发表评论

全部评论

专题导读

More+

10-27 六六分期app的软件客服如何联系？(六六分期

11-06 可心卡盟:win10系统火狐flash插件崩溃怎么

11-06 亲亲特价:怎么删除回收站图标

11-06 济南大学虚拟社区:鲁大师节能降温的具体办

11-06 xlueops.exe:无线网络安装向导

11-06 女斗合众国:win7系统cf与主机连接不稳定怎

11-06 0xc000022-[cf烟雾头]cf怎么调烟雾头

11-06 qizideyouhuo:应用程序无法正常启动0xc0000

11-06 ipz-185:win7系统vcf文件怎么打开

11-06 傻哥蹦迪:win10系统s4怎么打开usb调试

11-06 八神浩树gtaste:回收站清空了怎么恢复

11-06 妖尾之黑色守护:win10系统电脑没有1440x900

11-06 校园至尊魔王小说:win7系统浏览网页时字体

11-06 女斗合众国:win10系统访问共享文件夹提示请

11-06 tokyo hot n0654:恢复win7系统默认字体一招

11-06 雨酷仙境:设置win7系统转移临时文件夹腾出

11-06 阿穆纳伊之杖:win7系统开始菜单在右边还原

11-06 tunespotting:win10系统火狐flash插件总是

11-06 甘尔葛分析师：计谋网站seo关键词暴涨有什

11-06 蔡贵霖: 计谋网站seo关键词暴涨有什么秘密

11-06 博益网首页:ao3网页版进入不了解决方法

11-06 漏斗子专栏: 网站数据分析小白易懂精华篇

11-06 见证双虹怎么做:win7系统开启telnet命令的

11-06 颾狐蝶蜋:系统资源不足无法完成请求的服务

11-06 国光中学校歌:提交网站到alexa查询详细步骤

11-06 西安有情天:静态网页和动态网页的区别

11-06 红木雅尚斋:外部链接构造对网站的好处

11-06 前官礼遇：防止域名劫持–增强域安全性的10

11-06 密传二转答案: 中文分词算法有哪些

11-06 金泉家园邮编:百度快照劫持的表现及应对方

php文件上传发布时间：2022-07-10

php获取代理服务器真实内网IP方法发布时间：2022-07-10

tolgee/documentation: Documentation of T

1 PacktPublishing/Python-Machine-Learning-

PacktPublishing/Python-Machine-Learning-Second-Edition: Python Machine Learning

阅读：969|2022-08-18

2 sussillo/hfopt-matlab: A parallel, cpu-b

sussillo/hfopt-matlab: A parallel, cpu-based matlab implemention of the Hessian

阅读：993|2022-08-17

3 鲁东大学一米网:Win7系统USB驱动器RAM的操

win7系统电脑使用过程中有不少朋友表示遇到过win7系统USB驱动器RAM的状况，当出现win7

阅读：885|2022-11-06

4 emersion/go-ostatus: An OStatus library

emersion/go-ostatus: An OStatus library written in Go

阅读：751|2022-08-17

5 CVE-2022-22982

The vCenter Server contains a server-side request forgery (SSRF) vulnerability.

阅读：1064|2022-07-29

6 elipapa/markdown-cv: a simple template t

elipapa/markdown-cv: a simple template to write your CV in a readable markdown f

阅读：509|2022-08-17

7 zju-sclab/NDT-library: These is ndt libr

zju-sclab/NDT-library: These is ndt library for ndt_mapping and ndt_localization

阅读：732|2022-08-16

8 卡莉·蕾·吉普森是谁?不雅录像是怎么回事?

Call Me Maybe 中英字幕对于加拿大歌手卡莉·蕾·吉普森很多人有些陌生，她隶属于贾

阅读：628|2022-11-06

9 Delphi之TComponent类

TComponent类TComponent类直接由TPersistent派生。TComponent的独特特征是它的属性能

阅读：892|2022-07-18

10 drac/Material-Design-Color-Palette-for-I

drac/Material-Design-Color-Palette-for-Inkscape: Google Material Design Color Pa

阅读：364|2022-08-17

客服电话

电子邮件

PHP 类与对象全解析（二)

目录

7.Static关键字

8.抽象类 PHP5支持抽象类和抽象方法。

9.接口

10.重载

11.对象迭代

12.设计模式: 工厂模式和单例模式，　观察者模式，命令链模式和策略模式

请发表评论

全部评论

上一篇：

下一篇：

百度小程序-循环数据,图文左右互换排列

dphi-official/Machine_Learning_Bootcamp

juven/maven-bash-completion: Maven Bash

win7系统注册表编辑器打开的操作方法

微信小程序

tolgee/documentation: Documentation of T

Arkanosis/microstatus: Lightweight Masto

win7系统自选“睡眠”和“休眠”模式的操作

wolfparticle/machineLearningDeepLearning

lpdsdx/License-plate-character-Recogniti

万里平台临沂会场

关于我们

产品与服务

解决方案

139-2527-9053

客服电话

电子邮件

PHP 类与对象 全解析（ 二)

目录

7.Static关键字

8.抽象类 PHP5支持抽象类和抽象方法。

9.接口

10.重载

11.对象迭代

12.设计模式: 工厂模式和 单例模式， 观察者模式，命令链模式和策略模式

请发表评论

全部评论

上一篇：

下一篇：

百度小程序-循环数据,图文左右互换排列

dphi-official/Machine_Learning_Bootcamp

juven/maven-bash-completion: Maven Bash

win7系统注册表编辑器打开的操作方法

微信小程序

tolgee/documentation: Documentation of T

Arkanosis/microstatus: Lightweight Masto

win7系统自选“睡眠”和“休眠”模式的操作

wolfparticle/machineLearningDeepLearning

lpdsdx/License-plate-character-Recogniti

万里平台临沂会场

关于我们

产品与服务

解决方案

139-2527-9053

PHP 类与对象全解析（二)

12.设计模式: 工厂模式和单例模式，　观察者模式，命令链模式和策略模式