[关闭]
@a5635268 2016-02-23T11:58:35.000000Z 字数 4873 阅读 957

PHP中的抽象类与接口

PHP

抽象类

php5支持抽象类和抽象方法。类前加 abstract, 此类就成为抽象类,无法被实例化,此类天生就是用来被继承的,给子类提供了一个类的模板;
类方法前加 abstract,是抽象方法,抽象方法不能有方法体;

总结下来抽象类有以下几个特点:

  1. 类中有抽象方法,则此类一定要是抽象类;否则会报错;
  2. 抽象类中的方法不一定都是抽象方法;
  3. 决定类是否能被实例化取决于其是不是抽象类,就算其类中的方法全部都是具体的方法而类本身是抽象方法的话,也不能被实例化
  4. 抽象类中全是具体方法,但是抽象类又不能被实例化,又想用其里面的具体方法时,就可以通过继承的方式或者通过类来调用;
  5. 抽象类是用作被继承的类,所以其中的方法必须是public或者protected,又由于子类继承其父类不能令其权限越来越严格的规则,其子类也必须public或者protected;
  6. 如果是一个非抽象类继承抽象类,就必须要完成抽象类中的所有的所有抽象方法(并且参数及其参数的类型要一样),但如果是一个抽象类继承一个抽象类的话可以不必完成抽象类中的抽象方法(抽象类继承抽象类的目的就是扩展被继承的抽象类);

以下代码摘抄自燕十八公益课堂

  1. /*
  2. 春秋战国时期,燕零七 飞行器专家,能工巧匠. 
  3. 他写了一份图纸---飞行器制造术 
  4. 飞行器秘制图谱 
  5. 1: 要有一个有力的发动机,喷气式. 
  6. 2: 要有一个平衡舵,掌握平衡 
  7. 他的孙子问: 发动机怎么造呢? 
  8. 燕零七眼望夕阳: 我是造不出来,但我相信后代有人造出来 
  9. 燕零七的构想在当时的科技造不出来,即这个类只能在图纸化,无法实例化.
  10. ***/ 
  12. // 此时这个类没有具体的方法去实现,还太抽象. 
  13. // 因此我们把他做成一个抽象类 
  14. abstract class FlyIdea { 
  15.     // 大力引擎,当时也没法做,这个方法也实现不了,因此方法也是抽象的 
  16.     public abstract function engine();
  18.     // 平衡舵 
  19.     public abstract function blance(); 
  20.     /* 
  21.         注意:抽象方法 不能有方法体 
  22.         下面这样写是错误的 
  23.         public abstract function blance() { 
  24.         } 
  25.         Fatal error: Abstract function FlyIdea::engine() cannot contain body 
  26.     */ 
  27. } 
  29. /* 
  30. 抽象类不能 new 来实例化 
  31. 下面这行是错误的 
  32. $kongke = new FlyIdea(); 
  33. Cannot instantiate abstract class FlyIdea 
  34. */ 
  36. // 到了明朝,万户用火箭解决了发动机的问题 
  37. abstract class Rocket extends FlyIdea { 
  38.     // 万户把engine方法,给实现了,不再抽象了 
  39.     public function engine() { 
  40.         echo '点燃火药,失去平衡,嘭!<br />'; 
  41.     } 
  42.     // 但是万户实现不了平衡舵,因此平衡舵对于Rocket类来说,还是抽象的,类也是抽象的 
  43.     // 此处由于继承父类的也是抽象类,所以可以不必完成抽象类中的所有抽象方法;
  44. } 
  46. /* 
  47. 到了现代,燕十八亲自制作飞行器 
  48. 这个Fly类中,所以抽象方法,都已经实现了,不再是梦想. 
  49. */  
  51. //到了这个类就必须要完成所有的抽象方法;
  52. class Fly extends Rocket{ 
  53.     public function engine() { 
  54.         echo '有力一扔<br />'; 
  55.     } 
  56.     public function blance() { 
  57.         echo '两个纸翼保持平衡~~~'; 
  58.     } 
  59.     public function start() { 
  60.         $this->engine(); 
  61.         for($i=0;$i<10;$i++) { 
  62.             $this->blance(); 
  63.             echo '平稳飞行<br />'; 
  64.         } 
  65.     } 
  66. } 
  67. $apache = new Fly(); 
  68. $apache->start();

接口

接口是抽象方法和静态常量定义的集合。接口是一种特殊的抽象类，这种抽象类中只包含抽象方法和静态常量。接口中没有其它类型的内容。

总结如下:

  1. 接口是某类事物功能的抽象，本身方法默认全部是抽象的，不能有方法体；
  2. 接口的作用：指定了implements这些接口的类必须要包含接口里面的方法以及方法里面的参数,缺一不可。当然除了包含接口的这些方法外，可以增加其他的一些方法；
  3. 接口是可以继承的
  4. 接口是一堆方法的说明,不能加属性,但可以定义常量，定义的常量是不能被覆盖，访问方法是 接口名::常量名 或者 self::常量名
  5. 接口的方法必须是public;
  6. 类可以实现多接口

以下代码来自燕十八的公益课堂

  1.   <?php
  2.   header("Content-type: text/html; charset=utf-8");
  3.    /*
  4.     类: 是某一类事物的抽象,是某类对象的蓝图. 
  5.     比如: 女娲造人时,脑子中关于人的形象  就是人类 class Human 
  6.     如果,女娲决定造人时, 同时,形象又没最终定稿时, 
  7.     她脑子有哪些支离破碎的形象呢? 
  8.     她可能会这么思考: 
  9.     动物: 吃饭 
  10.     猴子: 奔跑 
  11.     猴子: 哭 
  12.     自己: 思考 
  13.     小鸟: 飞 
  14.     我造一种生物,命名为人,应该有如下功能 
  15.     eat() 
  16.     run(); 
  17.     cry(); 
  18.     think(); 
  19.     类如果是一种事物/动物的抽象 
  20.     那么 接口,则是事物/动物的功能的抽象, 
  21.     即,再把他们的功能各拆成小块 
  22.     自由组合成新的特种 
  23.     */ ;   
  24.     interface animal { 
  25.       const NAME = 'zxg'; //不能定义属性,但可以定义常量;
  26.       public function eat(); 
  27.     } 
  28.     interface monkey { 
  29.       public function run(); 
  30.       public function cry(); 
  31.     } 
  32.     interface wisdom { 
  33.       public function think(); 
  34.     } 
  35.     interface bird { 
  36.       public function fly();
  37.     } 
  39.   /*
  40.   如上,我们把每个类中的这种实现的功能拆出来 
  41.   分析: 如果有一种新生物,实现了eat() + run() +cry() + think() ,这种智慧生物,可以叫做人. 
  42.   class Human implements animal,monkey,wisdom { 
  44.   } 
  46.   Human类必须要包含animal,monkey,wisdom接口里面的方法,缺一不可,否则就会报错
  47.   Class Human contains 4 abstract methods 
  48.   */ 
  50.   class Human implements animal, monkey, wisdom, bird { //这里的接口数量可以随意增加;增加了以后本类里面的方法必须要有新增加的接口里面的方法
  51.       public function eat() {
  52.           echo "吃东西方法";
  53.       }
  54.       public function run() {
  55.           echo self::NAME; //可以通过self来访问任意一个接口所定义的常量;
  56.           echo '行走的方法';
  57.       }
  58.       public function cry() {
  59.           echo '哭的方法';
  60.       }
  61.       public function think() {
  62.           echo animal::NAME; //也可以通过 接口名
  63.           echo '思考的方法';
  64.       }
  65.       public function smile() {
  66.           echo "这是新增加的微笑方法";
  67.       }
  68.       public function fly() {
  69.           echo "这是新增加的接口bird里面的fly方法";
  70.       }
  71.   }
  73.   $obj = new Human();
  74.   $obj -> think();
  75.   ?>

区别

  1. 对接口的使用是通过关键字implements。对抽象类的使用是通过关键字extends。当然接口也可以通过关键字extends继承但最好还是通过implements实现。
  2. 接口中不可以声明成员变量（包括类静态变量），但是可以声明类常量。抽象类中可以声明各种类型成员变量，实现数据的封装。
  3. 接口中只有抽象方法没有具体的方法，抽象类可以有具体的方法。
  4. 接口中的方法默认都是public类型的，而抽象类中的方法可以使用protected,public来修饰（其实抽象类也可以声明private方法的，不过没有意义）。
  5. 一个类可以同时实现多个接口，但一个类只能继承于一个抽象类。

使用接口还是抽象类？

  1. 如果要创建一个模型，这个模型将由一些紧密相关的对象采用，就可以使用抽象类。如果要创建将由一些不相关对象采用的功能，就使用接口。
  2. 如果必须从多个来源继承行为，就使用接口（只有接口能继承多个）。
  3. 如果知道所有类都会共享一个公共的行为实现，就使用抽象类，并在其中实现该行为。

应用场景举例

更多的应用场景可以参考一些国外框架,比如YII

  1. <?php   
  2. //04.php   
  3. /***  
  4. ====笔记部分====  
  5. 面向对象的一个观点:  
  6. 做的越多,越容易犯错  
  7. 抽象类{就定义类模板}--具体子类实现{china,japan,english}  
  8. 接口:  
  9. ***/   
  10. // 抽象的数据库类   
  11. /*  
  12. 创业做网站  
  13. 到底用什么数据库?  mysql, oracle,sqlserver,postgresql?  
  14. 这样:先开发网站,运行再说.  
  15. 先弄个mysql开发着,正式上线了再换数据库也不迟  
  16. 引来问题:  
  17. 换数据库,会不会以前的代码又得重写?  
  18. 答:不必,用抽象类  
  19. 开发者,开发时,就以db抽象类来开发.  
  20. */   
  21. abstract class db {   
  22.     public abstract function connect($h,$u,$p);   
  23.     public abstract function query($sql);   
  24.     public abstract function close();   
  25. }   
  26. /*   
  27. // 下面这个代码有误  
  28. // 因为子类实现时, connect和抽象类的connect参数不一致  
  29. class mysql extends db {  
  30.     public function connect($h,$h) {  
  31.         return true;  
  32.     }  
  33.     public function query($sql,$conn) {  
  34.     }  
  35.     public function close() {  
  36.     }  
  37. }  
  38. */   
  39. /*  
  40. 下面这个mysql类,严格实现了db抽象类  
  41. 试想: 不管上线时,真正用什么数据库  
  42. 我只需要再写一份如下类  
  43. class oracle extends db {  
  44. }  
  45. class mssql extends db {  
  46. }  
  47. class postsql extends db {  
  48. }  
  49. 业务逻辑层不用改?  
  50. 为什么不用改?  
  51. 因为都实现的db抽象类.  
  52. 我开发时,调用方法不清楚的地方,我就可以参考db抽象类.  
  53. 反正子类都是严格实现的抽象类.  
  54. */   
  55. class mysql extends db {   
  56.     public function connect($h,$h,$u) {   
  57.         return true;   
  58.     }   
  59.     public function query($sql) {   
  60.     }   
  61.     public function close() {   
  62.     }   
  63. }   
  66. /*  
  67. 接口 就更加抽象了  
  68. 比如一个社交网站,  
  69. 关于用户的处理是核心应用.  
  70. 登陆  
  71. 退出  
  72. 写信  
  73. 看信  
  74. 招呼  
  75. 更换心情  
  76. 吃饭  
  77. 骂人  
  78. 捣乱  
  79. 示爱  
  80. 撩骚  
  81. 这么多的方法,都是用户的方法,  
  82. 自然可以写一个user类,全包装起来  
  83. 但是,分析用户一次性使不了这么方法  
  84. 用户信息类:{登陆,写信,看信,招呼,更换心情,退出}  
  85. 用户娱乐类:{登陆,骂人,捣乱,示爱,撩骚,退出}  
  86. 开发网站前,分析出来这么多方法,  
  87. 但是,不能都装在一个类里,  
  88. 分成了2个类,甚至更多.  
  89. 作用应用逻辑的开发,这么多的类,这么多的方法,都晕了.  
  90. */   
  91. interface UserBase {   
  92.     public function login($u,$p);   
  93.     public function logout();   
  94. }   
  95. interface UserMsg {   
  96.     public function wirteMsg($to,$title,$content);   
  97.     public function readMsg($from,$title);   
  98. }   
  99. interface UserFun {   
  100.     public function spit($to);   
  101.     public function showLove($to);   
  102. }   
  103. /*  
  104. 作为调用者, 我不需要了解你的用户信息类,用户娱乐类,  
  105. 我就可以知道如何调用这两个类  
  106. 因为: 这两个类 都要实现 上述接口.  
  107. 通过这个接口,就可以规范开发.  
  108. */   
  109. /*  
  110. 下面这个类,和接口声明的参数不一样,就报错,  
  111. 这样,接口强制统一了类的功能  
  112. 不管你有几个类,一个类中有几个方法  
  113. 我只知道,方法都是实现的接口的方法.  
  114. */   
  115. class User implements UserBase {   
  116.     public function login($u) {   
  117.     }   
  118. }   
  119. ?>
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注