程序博客网 > 淘宝商家提现手续费

设计模式六大原则（4）：接口隔离原则

来源：互联网 发布：淘宝商家提现手续费 编辑：程序博客网 时间：2024/06/05 06:46
 
    
定义：客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。

问题由来：类A通过接口I依赖类B，类C通过接口I依赖类D，如果接口I对于类A和类B来说不是最小接口，则类B和类D必须去实现他们不需要的方法。

解决方案：将臃肿的接口I拆分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则。

举例来说明接口隔离原则：

（图1  未遵循接口隔离原则的设计）

         这个图的意思是：类A依赖接口I中的方法1、方法2、方法3，类B是对类A依赖的实现。类C依赖接口I中的方法1、方法4、方法5，类D是对类C依赖的实现。对于类B和类D来说，虽然他们都存在着用不到的方法（也就是图中红色字体标记的方法），但由于实现了接口I，所以也必须要实现这些用不到的方法。对类图不熟悉的可以参照程序代码来理解，代码如下：

[java] 
interface I {  
  1.     public void method1();  
  2.     public void method2();  
  3.     public void method3();  
  4.     public void method4();  
  5.     public void method5();  
  6. }  
  7.   
  8. class A{  
  9.     public void depend1(I i){  
  10.         i.method1();  
  11.     }  
  12.     public void depend2(I i){  
  13.         i.method2();  
  14.     }  
  15.     public void depend3(I i){  
  16.         i.method3();  
  17.     }  
  18. }  
  19.   
  20. class B implements I{  
  21.     public void method1() {  
  22.         System.out.println("类B实现接口I的方法1");  
  23.     }  
  24.     public void method2() {  
  25.         System.out.println("类B实现接口I的方法2");  
  26.     }  
  27.     public void method3() {  
  28.         System.out.println("类B实现接口I的方法3");  
  29.     }  
  30.     //对于类B来说，method4和method5不是必需的，但是由于接口A中有这两个方法，   
  31.     //所以在实现过程中即使这两个方法的方法体为空，也要将这两个没有作用的方法进行实现。   
  32.     public void method4() {}  
  33.     public void method5() {}  
  34. }  
  35.   
  36. class C{  
  37.     public void depend1(I i){  
  38.         i.method1();  
  39.     }  
  40.     public void depend2(I i){  
  41.         i.method4();  
  42.     }  
  43.     public void depend3(I i){  
  44.         i.method5();  
  45.     }  
  46. }  
  47.   
  48. class D implements I{  
  49.     public void method1() {  
  50.         System.out.println("类D实现接口I的方法1");  
  51.     }  
  52.     //对于类D来说，method2和method3不是必需的，但是由于接口A中有这两个方法，   
  53.     //所以在实现过程中即使这两个方法的方法体为空，也要将这两个没有作用的方法进行实现。   
  54.     public void method2() {}  
  55.     public void method3() {}  
  56.   
  57.     public void method4() {  
  58.         System.out.println("类D实现接口I的方法4");  
  59.     }  
  60.     public void method5() {  
  61.         System.out.println("类D实现接口I的方法5");  
  62.     }  
  63. }  
  64.   
  65. public class Client{  
  66.     public static void main(String[] args){  
  67.         A a = new A();  
  68.         a.depend1(new B());  
  69.         a.depend2(new B());  
  70.         a.depend3(new B());  
  71.           
  72.         C c = new C();  
  73.         c.depend1(new D());  
  74.         c.depend2(new D());  
  75.         c.depend3(new D());  
  76.     }  
  77. }  
     
interface I { public void method1(); public void method2(); public void method3(); public void method4(); public void method5();}class A{ public void depend1(I i){i.method1(); } public void depend2(I i){ i.method2(); } public void depend3(I i){ i.method3(); }}class B implements I{ public void method1() { System.out.println("类B实现接口I的方法1"); } public void method2() { System.out.println("类B实现接口I的方法2"); } public void method3() { System.out.println("类B实现接口I的方法3"); } //对于类B来说，method4和method5不是必需的，但是由于接口A中有这两个方法，//所以在实现过程中即使这两个方法的方法体为空，也要将这两个没有作用的方法进行实现。 public void method4() {} public void method5() {}}class C{ public void depend1(I i){ i.method1(); } public void depend2(I i){ i.method4(); } public void depend3(I i){ i.method5(); }}class D implements I{ public void method1() { System.out.println("类D实现接口I的方法1"); } //对于类D来说，method2和method3不是必需的，但是由于接口A中有这两个方法，//所以在实现过程中即使这两个方法的方法体为空，也要将这两个没有作用的方法进行实现。public void method2() {} public void method3() {} public void method4() { System.out.println("类D实现接口I的方法4"); } public void method5() { System.out.println("类D实现接口I的方法5"); }}public class Client{ public static void main(String[] args){ A a = new A(); a.depend1(new B()); a.depend2(new B()); a.depend3(new B()); C c = new C(); c.depend1(new D()); c.depend2(new D()); c.depend3(new D()); }}}

   可以看到，如果接口过于臃肿，只要接口中出现的方法，不管对依赖于它的类有没有用处，实现类中都必须去实现这些方法，这显然不是好的设计。如果将这个设计修改为符合接口隔离原则，就必须对接口I进行拆分。在这里我们将原有的接口I拆分为三个接口，拆分后的设计如图2所示：


（图2  遵循接口隔离原则的设计）

照例贴出程序的代码，供不熟悉类图的朋友参考：

[java] 
interface I1 {  
  1.     public void method1();  
  2. }  
  3.   
  4. interface I2 {  
  5.     public void method2();  
  6.     public void method3();  
  7. }  
  8.   
  9. interface I3 {  
  10.     public void method4();  
  11.     public void method5();  
  12. }  
  13.   
  14. class A{  
  15.     public void depend1(I1 i){  
  16.         i.method1();  
  17.     }  
  18.     public void depend2(I2 i){  
  19.         i.method2();  
  20.     }  
  21.     public void depend3(I2 i){  
  22.         i.method3();  
  23.     }  
  24. }  
  25.   
  26. class B implements I1, I2{  
  27.     public void method1() {  
  28.         System.out.println("类B实现接口I1的方法1");  
  29.     }  
  30.     public void method2() {  
  31.         System.out.println("类B实现接口I2的方法2");  
  32.     }  
  33.     public void method3() {  
  34.         System.out.println("类B实现接口I2的方法3");  
  35.     }  
  36. }  
  37.   
  38. class C{  
  39.     public void depend1(I1 i){  
  40.         i.method1();  
  41.     }  
  42.     public void depend2(I3 i){  
  43.         i.method4();  
  44.     }  
  45.     public void depend3(I3 i){  
  46.         i.method5();  
  47.     }  
  48. }  
  49.   
  50. class D implements I1, I3{  
  51.     public void method1() {  
  52.         System.out.println("类D实现接口I1的方法1");  
  53.     }  
  54.     public void method4() {  
  55.         System.out.println("类D实现接口I3的方法4");  
  56.     }  
  57.     public void method5() {  
  58.         System.out.println("类D实现接口I3的方法5");  
  59.     }  
  60. }  
interface I1 { public void method1();}interface I2 { public void method2(); public void method3();}interface I3 { public void method4(); public void method5();}class A{ public void depend1(I1 i){i.method1(); } public void depend2(I2 i){ i.method2(); } public void depend3(I2 i){ i.method3(); }}class B implements I1, I2{ public void method1() { System.out.println("类B实现接口I1的方法1");} public void method2() { System.out.println("类B实现接口I2的方法2"); } public void method3() { System.out.println("类B实现接口I2的方法3"); }}class C{ public void depend1(I1 i){ i.method1(); } public void depend2(I3 i){ i.method4(); } public void depend3(I3 i){ i.method5(); }}class D implements I1, I3{ public void method1() { System.out.println("类D实现接口I1的方法1"); } public void method4() { System.out.println("类D实现接口I3的方法4"); } public void method5() { System.out.println("类D实现接口I3的方法5"); }}

        接口隔离原则的含义是：建立单一接口，不要建立庞大臃肿的接口，尽量细化接口，接口中的方法尽量少。也就是说，我们要为各个类建立专用的接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。本文例子中，将一个庞大的接口变更为3个专用的接口所采用的就是接口隔离原则。在程序设计中，依赖几个专用的接口要比依赖一个综合的接口更灵活。接口是设计时对外部设定的“契约”，通过分散定义多个接口，可以预防外来变更的扩散，提高系统的灵活性和可维护性。

         说到这里，很多人会觉的接口隔离原则跟之前的单一职责原则很相似，其实不然。其一，单一职责原则原注重的是职责；而接口隔离原则注重对接口依赖的隔离。其二，单一职责原则主要是约束类，其次才是接口和方法，它针对的是程序中的实现和细节；而接口隔离原则主要约束接口接口，主要针对抽象，针对程序整体框架的构建。

         采用接口隔离原则对接口进行约束时，要注意以下几点：

  • 接口尽量小，但是要有限度。对接口进行细化可以提高程序设计灵活性是不挣的事实，但是如果过小，则会造成接口数量过多，使设计复杂化。所以一定要适度。
  • 为依赖接口的类定制服务，只暴露给调用的类它需要的方法，它不需要的方法则隐藏起来。只有专注地为一个模块提供定制服务，才能建立最小的依赖关系。
  • 提高内聚，减少对外交互。使接口用最少的方法去完成最多的事情。

运用接口隔离原则，一定要适度，接口设计的过大或过小都不好。设计接口的时候，只有多花些时间去思考和筹划，才能准确地实践这一原则。

        可以看到，如果接口过于臃肿，只要接口中出现的方法，不管对依赖于它的类有没有用处，实现类中都必须去实现这些方法，这显然不是好的设计。如果将这个设计修改为符合接口隔离原则，就必须对接口I进行拆分。在这里我们将原有的接口I拆分为三个接口，拆分后的设计如图2所示：


（图2  遵循接口隔离原则的设计）

照例贴出程序的代码，供不熟悉类图的朋友参考：

[java] view plaincopyprint?
  1. interface I1 {  
  2.     public void method1();  
  3. }  
  4.   
  5. interface I2 {  
  6.     public void method2();  
  7.     public void method3();  
  8. }  
  9.   
  10. interface I3 {  
  11.     public void method4();  
  12.     public void method5();  
  13. }  
  14.   
  15. class A{  
  16.     public void depend1(I1 i){  
  17.         i.method1();  
  18.     }  
  19.     public void depend2(I2 i){  
  20.         i.method2();  
  21.     }  
  22.     public void depend3(I2 i){  
  23.         i.method3();  
  24.     }  
  25. }  
  26.   
  27. class B implements I1, I2{  
  28.     public void method1() {  
  29.         System.out.println("类B实现接口I1的方法1");  
  30.     }  
  31.     public void method2() {  
  32.         System.out.println("类B实现接口I2的方法2");  
  33.     }  
  34.     public void method3() {  
  35.         System.out.println("类B实现接口I2的方法3");  
  36.     }  
  37. }  
  38.   
  39. class C{  
  40.     public void depend1(I1 i){  
  41.         i.method1();  
  42.     }  
  43.     public void depend2(I3 i){  
  44.         i.method4();  
  45.     }  
  46.     public void depend3(I3 i){  
  47.         i.method5();  
  48.     }  
  49. }  
  50.   
  51. class D implements I1, I3{  
  52.     public void method1() {  
  53.         System.out.println("类D实现接口I1的方法1");  
  54.     }  
  55.     public void method4() {  
  56.         System.out.println("类D实现接口I3的方法4");  
  57.     }  
  58.     public void method5() {  
  59.         System.out.println("类D实现接口I3的方法5");  
  60.     }  
  61. }  
interface I1 { public void method1();}
interface I2 {
    public void method2();
    public void method3();
}
interface I3 {
    public void method4();
    public void method5();
    }
 
class A{
    public void depend1(I1 i){ 
    i.method1();
    }
    public void depend2(I2 i){
    i.method2();
    }
    public void depend3(I2 i){
     i.method3();
    }
}
 
class B implements I1, I2{
     public void method1() {
     System.out.println("类B实现接口I1的方法1");
     }
     public void method2() {
     System.out.println("类B实现接口I2的方法2");
     }
     public void method3() {
     System.out.println("类B实现接口I2的方法3");
     }
}
 
class C{
     public void depend1(I1 i){
     i.method1();
     }
     public void depend2(I3 i){
     i.method4();
     }
     public void depend3(I3 i){
     i.method5();
     }
}
 
class D implements I1, I3{
      public void method1() {
      System.out.println("类D实现接口I1的方法1");
      }
      public void method4() {
      System.out.println("类D实现接口I3的方法4");
      }
      public void method5() {
      System.out.println("类D实现接口I3的方法5");
      }
}

        接口隔离原则的含义是：建立单一接口，不要建立庞大臃肿的接口，尽量细化接口，接口中的方法尽量少。也就是说，我们要为各个类建立专用的接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。本文例子中，将一个庞大的接口变更为3个专用的接口所采用的就是接口隔离原则。在程序设计中，依赖几个专用的接口要比依赖一个综合的接口更灵活。接口是设计时对外部设定的“契约”，通过分散定义多个接口，可以预防外来变更的扩散，提高系统的灵活性和可维护性。

         说到这里，很多人会觉的接口隔离原则跟之前的单一职责原则很相似，其实不然。其一，单一职责原则原注重的是职责；而接口隔离原则注重对接口依赖的隔离。其二，单一职责原则主要是约束类，其次才是接口和方法，它针对的是程序中的实现和细节；而接口隔离原则主要约束接口接口，主要针对抽象，针对程序整体框架的构建。

         采用接口隔离原则对接口进行约束时，要注意以下几点：

  • 接口尽量小，但是要有限度。对接口进行细化可以提高程序设计灵活性是不挣的事实，但是如果过小，则会造成接口数量过多，使设计复杂化。所以一定要适度。
  • 为依赖接口的类定制服务，只暴露给调用的类它需要的方法，它不需要的方法则隐藏起来。只有专注地为一个模块提供定制服务，才能建立最小的依赖关系。
  • 提高内聚，减少对外交互。使接口用最少的方法去完成最多的事情。

运用接口隔离原则，一定要适度，接口设计的过大或过小都不好。设计接口的时候，只有多花些时间去思考和筹划，才能准确地实践这一原则。

淘宝商家提现手续费 淘宝商家提现手续费
原创粉丝点击
热门IT博客
百度开放性域名百度开放性域名
tcp 高并发框架javatcp 高并发框架java
查淘宝排名的软件
淘宝企业店铺流程
2017怎么申请淘宝达人
原创搞笑网络剧排行榜
原画网络培训
4.4数据的离散程度
nginx监听多个端口
洗水标打印软件
天文模拟软件
java静态常量
淘宝怎么样提高销量
java微商城源码
unity3d人物移动转向
斗鱼包大人的淘宝店名
js把map转换为对象
耳机降噪软件
dreamweaver连接数据库
dw运行js文件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 皮包发霉了怎么去霉斑 怎样去除衣服上的霉点霉斑 衣服起黑色霉点清洗妙招 霉点怎么洗掉 衣服有黑霉点用醋能洗干净吗 衣服霉点该如清洗妙招 衣服有霉点该如清洗 衣服霉点 衣服黑色霉点怎样清除 衣服上的霉点怎么去除小窍门 衣服上霉点怎样洗掉 点青霉过敏 衣服上的霉点怎么洗掉 皮衣上的霉点怎么去除 衣服起霉点怎么办 衣服上的霉点怎么去除 如何去掉衣服上的霉点 制霉菌素 制霉菌素片 霉菌用药 霉菌素 霉菌的危害 霉菌过敏 霉菌毒素 霉菌培养箱 霉菌严重吗 根霉菌 毛霉菌 霉菌图片 霉菌炎 霉菌症状 霉菌+ 检出霉菌 霉菌的特性 霉菌性阴炎原因 男性感染霉菌可自行恢复吗 女人霉菌感染照片照片 霉菌性阴炎用药 女性霉菌感染图片 女性霉菌感染症状图片 女性轻度霉菌图片

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里