设计模式七大原则

「爱情、让人受尽委屈。」 2022-12-29 06:54 270阅读 0赞

#

  • 设计模式七大原则
    • 一、设计模式的目的
    • 二、设计模式七大原则
      • 1、单一职责原则
      • 2、接口隔离原则(Interface Segregation Principle)
      • 3、依赖倒转原则
      • 4、里氏替换原则
      • 5、开闭原则
      • 6、迪米特法则
      • 7、合成复用原则（Composite Reuse Principle）
    • 三、设计原则核心思想

设计模式七大原则

一、设计模式的目的

编写软件过程中，程序员面临着来自 耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性 等多方面的挑战，设计模式是为了让程序(软件)，具有更好

  1. 代码重用性 (即：相同功能的代码，不用多次编写)
  2. 可读性 (即：编程规范性, 便于其他程序员的阅读和理解)
  3. 可扩展性 (即：当需要增加新的功能时，非常的方便，称为可维护)
  4. 可靠性 (即：当我们增加新的功能后，对原来的功能没有影响)
  5. 使程序呈现高内聚，低耦合的特性

二、设计模式七大原则

设计模式原则，其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础（即：设计模式为什么这样设计的依据）

设计模式常用的七大原则有：

  1. 单一职责原则
  2. 接口隔离原则
  3. 依赖倒转(倒置)原则
  4. 里氏替换原则
  5. 开闭原则
  6. 迪米特法则
  7. 合成复用原则

1、单一职责原则

基本介绍

对类来说的，即一个类应该只负责一项职责。如类 A 负责两个不同职责：职责 1，职责 2。当职责 1 需求变更而改变 A 时，可能造成职责 2 执行错误，所以需要将类 A 的粒度分解为 A1，A2

应用实例

以交通工具案例讲解

方案1：

  1. package principle.singleresponsibility;
  3. public class SingleResponsibility1 { 
  4.     public static void main(String[] args) { 
  5.         Vehicle vehicle = new Vehicle();
  6.         vehicle.run("摩托车");
  7.         vehicle.run("汽车");
  8.         vehicle.run("飞机");
  10.     }
  11. }
  13. // 交通工具类
  14. // 方 式 1
  15. // 1. 在方式 1 的 run 方法中，违反了单一职责原则
  16. // 2. 解决的方案非常的简单，根据交通工具运行方法不同，分解成不同类即可
  17. class Vehicle { 
  18.     public void run(String vehicle) { 
  19.         System.out.println(vehicle + " 在公路上运行....");
  20.     }
  21. }

方案2：

  1. package principle.singleresponsibility;
  3. public class SingleResponsibility2 { 
  4.     public static void main(String[] args) { 
  5.         RoadVehicle roadVehicle = new RoadVehicle();
  6.         roadVehicle.run("摩托车");
  7.         roadVehicle.run("汽车");
  9.         AirVehicle airVehicle = new AirVehicle();
  10.         airVehicle.run("飞机");
  11.     }
  12. }
  14. //方案 2 的分析
  15. //1. 遵守单一职责原则
  16. //2. 但是这样做的改动很大，即将类分解，同时修改客户端
  17. //3. 改进：直接修改 Vehicle 类，改动的代码会比较少=>方案 3
  19. class RoadVehicle { 
  20.     public void run(String vehicle) { 
  21.         System.out.println(vehicle + "公路运行");
  22.     }
  23. }
  26. class AirVehicle { 
  27.     public void run(String vehicle) { 
  28.         System.out.println(vehicle + "天空运行");
  29.     }
  30. }
  32. class WaterVehicle { 
  33.     public void run(String vehicle) {  
  34.         System.out.println(vehicle + "水中运行");
  35.     }`
  36. }

方案3：

  1. package principle.singleresponsibility;
  3. public class SingleResponsibility3 { 
  4.     public static void main(String[] args) { 
  5.         Vehicle2 vehicle2    = new Vehicle2();
  6.         vehicle2.run("汽车");
  7.         vehicle2.runWater("轮船");
  8.         vehicle2.runAir("飞机");
  10.     }
  11. }
  14. //1. 这种修改方法没有对原来的类做大的修改，只是增加方法
  15. //2. 这里虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上，仍然是遵守单一职责
  16. class Vehicle2 { 
  17.     public void run(String vehicle) { 
  18.         //处理
  19.         System.out.println(vehicle + " 在公路上运行....");
  21.     }
  23.     public void runAir(String vehicle) { 
  24.         System.out.println(vehicle + " 在天空上运行....");
  25.     }
  28.     public void runWater(String vehicle) { 
  29.         System.out.println(vehicle + " 在水中行....");
  30.     }
  32. }

单一职责原则注意事项和细节

  • 降低类的复杂度，一个类只负责一项职责。
  • 提高类的可读性，可维护性
  • 降低变更引起的风险
  • 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则

2、接口隔离原则(Interface Segregation Principle)

基本介绍

1、客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。

2、先看一张图：
在这里插入图片描述

  • 类 A 通过接口 Interface1 依赖类 B，类 C 通过接口 Interface1 依赖类 D，如果接口 Interface1 对于类 A 和类 C 来说不是最小接口，那么类 B 和类 D 必须去实现他们不需要的方法。
  • 按隔离原则应当这样处理：
    将接口 Interface1 拆分为独立的几个接口(这里我们拆分成 3 个接口)，类 A 和类 C 分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则。

应用实例

1、类 A 通过接口 Interface1 依赖类 B，类 C 通过接口 Interface1 依赖类 D，请编写代码完成此应用实例。

2、没有使用接口隔离原则代码

  1. package principle.segregation;
  3. public class Segregation1 { 
  4.     public static void main(String[] args) { 
  6.     }
  7. }
  9. //接口
  10. interface Interface1 { 
  12.     void operation1();
  14.     void operation2();
  16.     void operation3();
  18.     void operation4();
  20.     void operation5();
  21. }
  23. class B implements Interface1 { 
  24.     public void operation1() { 
  25.         System.out.println("B 实现了 operation1");
  26.     }
  28.     public void operation2() { 
  29.         System.out.println("B 实现了 operation2");
  30.     }
  31.     public void operation3() { 
  32.         System.out.println("B 实现了 operation3");
  33.     }
  34.     public void operation4() { 
  35.         System.out.println("B 实现了 operation4");
  36.     }
  37.     public void operation5() { 
  38.         System.out.println("B 实现了 operation5");
  39.     }
  40. }
  42. class D implements Interface1 { 
  44.     public void operation1() { 
  45.         System.out.println("D 实现了 operation1");
  46.     }
  48.     public void operation2() { 
  49.         System.out.println("D 实现了 operation2");
  50.     }
  52.     public void operation3() { 
  53.         System.out.println("D 实现了 operation3");
  54.     }
  56.     public void operation4() { 
  57.         System.out.println("D 实现了 operation4");
  58.     }
  60.     public void  operation5()  { 
  61.         System.out.println("D 实现了 operation5");
  62.     }
  64. }
  66. class A { 
  67.     //A 类通过接口 Interface1 依赖(使用) B 类，但是只会用到 1,2,3 方法
  68.     public void depend1(Interface1 i) { 
  69.         i.operation1();
  70.     }
  72.     public void depend2(Interface1 i) { 
  73.         i.operation2();
  74.     }
  76.     public void depend3(Interface1 i) { 
  77.         i.operation3();
  78.     }
  79. }
  81. class C {  
  82.     //C 类通过接口 Interface1 依赖(使用) D 类，但是只会用到 1,4,5 方法
  83.     public void depend1(Interface1 i) { 
  84.         i.operation1();
  85.     }
  86.     public void depend4(Interface1 i) { 
  87.         i.operation4();
  88.     }
  89.     public void depend5(Interface1 i) { 
  90.         i.operation5();
  91.     }
  92. }

应传统方法的问题和使用接口隔离原则改进

1、类 A 通过接口 Interface1 依赖类 B，类 C 通过接口 Interface1 依赖类 D，如果接口 Interface1 对于类 A 和类 C 来说不是最小接口，那么类 B 和类 D 必须去实现他们不需要的方法。

2、将接口 Interface1 拆分为独立的几个接口，类 A 和类 C 分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则。

3、接口 Interface1 中出现的方法，根据实际情况拆分为三个接口。

在这里插入图片描述

  1. package principle.segregation.improve;
  3. public class Segregation1 { 
  4.     public static void main(String[] args) { 
  5.         // 使用一把
  6.         A a = new A();
  7.         a.depend1(new B()); // A 类通过接口去依赖 B 类
  8.         a.depend2(new B());
  9.         a.depend3(new B());
  11.         C c = new C();
  12.         c.depend1(new D()); // C 类通过接口去依赖(使用)D 类
  13.         c.depend4(new D());
  14.         c.depend5(new D());
  16.     }
  17. }
  19. // 接 口 1
  20. interface Interface1 { 
  21.     void operation1();
  22. }
  24. // 接 口 2
  25. interface Interface2 { 
  26.     void operation2();
  27.     void operation3();
  28. }
  30. // 接 口 3
  31. interface Interface3 { 
  32.     void operation4();
  33.     void operation5();
  34. }
  36. class B implements Interface1, Interface2 { 
  37.     public void operation1() { 
  38.         System.out.println("B 实现了 operation1");
  39.     }
  41.     public void operation2() { 
  42.         System.out.println("B 实现了 operation2");
  43.     }
  45.     public void operation3() { 
  46.         System.out.println("B 实现了 operation3");
  47.     }
  49. }
  51. class D implements Interface1, Interface3 { 
  52.     public void operation1() { 
  53.         System.out.println("D 实现了 operation1");
  54.     }
  57.     public void operation4() { 
  58.         System.out.println("D 实现了 operation4");
  59.     }
  62.     public void operation5() { 
  63.         System.out.println("D 实现了 operation5");
  64.     }
  65. }
  67. class A { 
  68.     // A 类通过接口 Interface1,Interface2 依赖(使用) B 类，但是只会用到 1,2,3 方法
  69.     public void depend1(Interface1 i) { 
  70.         i.operation1();
  71.     }
  73.     public void depend2(Interface2 i) { 
  74.         i.operation2();
  75.     }
  77.     public void depend3(Interface2 i) { 
  78.         i.operation3();
  79.     }
  80. }
  82. class C { 
  83.     // C 类通过接口 Interface1,Interface3 依赖(使用) D 类，但是只会用到 1,4,5 方法
  84.     public void depend1(Interface1 i) { 
  85.         i.operation1();
  86.     }
  89.     public void depend4(Interface3 i) { 
  90.         i.operation4();
  91.     }
  94.     public void depend5(Interface3 i) { 
  95.         i.operation5();
  96.     }
  97. }

3、依赖倒转原则

基本介绍

依赖倒转原则(Dependence Inversion Principle)是指：

  1. 高层模块不应该依赖低层模块，二者都应该依赖其抽象
  2. 抽象不应该依赖细节，细节应该依赖抽象
  3. 依赖倒转(倒置)的中心思想是面向接口编程
  4. 依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在 java 中，抽象指的是接口或抽象类，细节就是具体的实现类
  5. 使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成

应用实例

编程完成 Person 接收消息 的功能。

方案1：

  1. package principle.inversion;
  3. public class DependecyInversion { 
  4.     public static void main(String[] args) { 
  5.         Person person = new Person();
  6.         person.receive(new Email());
  7.     }
  8. }
  10. class Email { 
  11.     public String getInfo() { 
  12.         return "电子邮件信息: hello,world";
  13.     }
  14. }
  16. //完成 Person 接收消息的功能
  17. //方式 1 分析
  18. //1. 简单，比较容易想到
  19. //2. 如果我们获取的对象是 微信，短信等等，则新增类，同时 Perons 也要增加相应的接收方法
  20. //3. 解决思路：引入一个抽象的接口 IReceiver, 表示接收者, 这样 Person 类与接口 IReceiver 发生依赖
  21. // 因为 Email, WeiXin 等等属于接收的范围，他们各自实现 IReceiver 接口就 ok, 这样我们就符号依赖倒转原则
  22. class Person { 
  23.     public void receive(Email email ) { 
  24.         System.out.println(email.getInfo());
  25.     }
  26. }

方案2：

  1. package principle.inversion.improve;
  3. public class DependecyInversion { 
  4.     public static void main(String[] args) { 
  5.         //客户端无需改变
  6.         Person person = new Person(); person.receive(new Email());
  7.         person.receive(new WeiXin());
  8.     }
  10. }
  12. //定义接口
  13. interface IReceiver { 
  14.     public String getInfo();
  15. }
  17. class Email implements IReceiver { 
  18.     public String getInfo() { 
  19.         return "电子邮件信息: hello,world";
  20.     }
  21. }
  23. //增加微信
  24. class WeiXin implements IReceiver {  
  25.     public String getInfo() { 
  26.         return "微信信息: hello,ok";
  27.     }
  28. }
  30. //方式 2
  31. class Person { 
  32.     //这里我们是对接口的依赖
  33.     public void receive(IReceiver receiver ) {  
  34.         System.out.println(receiver.getInfo());
  35.     }
  36. }

依赖关系传递的三种方式和应用案例

1、接口传递

2、构造方法传递

3、setter 方式传递

  1. package principle.inversion.improve;
  3. public class DependencyPass { 
  4.     public static void main(String[] args) { 
  5.         ChangHong changHong = new ChangHong();
  6.     // OpenAndClose openAndClose = new OpenAndClose();
  7.     // openAndClose.open(changHong);
  9.     // 通过构造器进行依赖传递
  10.     // OpenAndClose openAndClose = new OpenAndClose(changHong);
  11.     // openAndClose.open();
  12.     // 通过 setter 方法进行依赖传递
  13.         OpenAndClose openAndClose = new OpenAndClose();
  14.         openAndClose.setTv(changHong);
  15.         openAndClose.open();
  17.     }
  18. }
  20. // 方式 1： 通过接口传递实现依赖
  21. // 开关的接口
  22. // interface IOpenAndClose { 
  23. // public void open(ITV tv); //抽象方法,接收接口
  24. // }
  25. //
  26. // interface ITV { //ITV 接口
  27. // public void play();
  28. // }
  29. //
  30. // class ChangHong implements ITV { 
  31. //
  32. // @Override
  33. // public void play() { 
  34. // // TODO Auto-generated method stub
  35. // System.out.println("长虹电视机，打开");
  36. // }
  37. //
  38. // }
  39.  实现接口
  40. // class OpenAndClose implements IOpenAndClose{ 
  41. // public void open(ITV tv){ 
  42. // tv.play();
  43. // }
  44. // }
  46. // 方式 2: 通过构造方法依赖传递
  47. // interface IOpenAndClose { 
  48. // public void open(); //抽象方法
  49. // }
  50. // interface ITV { //ITV 接口
  51. // public void play();
  52. // }
  53. // class OpenAndClose implements IOpenAndClose{ 
  54. // public ITV tv; //成员
  55. // public OpenAndClose(ITV tv){ //构造器
  56. // this.tv = tv;
  57. // }
  58. // public void open(){ 
  59. // this.tv.play();
  60. // }
  61. // }
  65. // 方式 3 , 通过 setter 方法传递
  66. interface IOpenAndClose { 
  67.     public void open(); // 抽象方法
  68.     public void setTv(ITV tv);
  69. }
  71. interface ITV { 
  72.     // ITV 接口
  73.     public void play();
  74. }
  76. class OpenAndClose implements IOpenAndClose { 
  77.     private ITV tv;
  79.     public void setTv(ITV tv) { 
  80.         this.tv = tv;
  81.     }
  83.     public void open() { 
  84.         this.tv.play();
  85.     }
  86. }
  89. class ChangHong implements ITV { 
  90.     @Override
  91.     public void play() { 
  92.         System.out.println("长虹电视机，打开");
  93.     }
  94. }

依赖倒转原则的注意事项和细节

  • 低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好.
  • 变量的声明类型尽量是抽象类或接口, 这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序扩展和优化
  • 继承时遵循里氏替换原则

4、里氏替换原则

OO 中的继承性的思考和说明

1、继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏。

2、继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低， 增加对象间的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到子类的功能都有可能产生故障

3、问题提出：在编程中，如何正确的使用继承? => 里氏替换原则

基本介绍

  • 里氏替换原则(Liskov Substitution Principle)在 1988 年，由麻省理工学院的一位姓里的女士提出的。
  • 如果对每个类型为 T1 的对象 o1，都有类型为 T2 的对象 o2，使得以 T1 定义的所有程序 P 在所有的对象 o1 都代换成 o2 时，程序 P 的行为没有发生变化，那么类型 T2 是类型 T1 的子类型。换句话说，所有引用基类的地方必须能透明地使用其子类的对象。
  • 在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法
  • 里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖 来解决问题。

一个程序引出的问题和思考

  1. package principle.liskov;
  3. public class Liskov { 
  4.     public static void main(String[] args) { 
  5.         A a = new A();
  6.         System.out.println("11-3=" + a.func1(11, 3));
  7.         System.out.println("1-8=" + a.func1(1, 8));
  9.         System.out.println("-----------------------");
  10.         B b = new B();
  11.         System.out.println("11-3=" + b.func1(11, 3));//这里本意是求出 11-3
  12.         System.out.println("1-8=" + b.func1(1, 8));// 1-8
  13.         System.out.println("11+3+9=" + b.func2(11, 3));
  15.     }
  17. }
  20. // A类
  21. class A { 
  22.     // 返回两个数的差
  23.     public int func1(int num1, int num2) { 
  24.         return num1 - num2;
  25.     }
  26. }
  28. // B 类继承了 A
  29. // 增加了一个新功能：完成两个数相加,然后和 9 求和
  30. class B extends A { 
  31.     //这里，重写了 A 类的方法, 可能是无意识
  32.     public int func1(int a, int b) { 
  33.         return a + b;
  34.     }
  36.     public int func2(int a, int b) { 
  37.         return func1(a, b) + 9;
  38.     }
  39. }

解决方法

  1. 我们发现原来运行正常的相减功能发生了错误。原因就是类 B 无意中重写了父类的方法，造成原有功能出现错误。在实际编程中，我们常常会通过重写父类的方法完成新的功能，这样写起来虽然简单，但整个继承体系的复用性会比较差。特别是运行多态比较频繁的时候
  2. 通用的做法是：原来的父类和子类都继承一个更通俗的基类，原有的继承关系去掉，采用依赖，聚合，组合等关系代替.
  3. 改进方案

在这里插入图片描述

  1. package principle.liskov.improve;
  3. public class Liskov { 
  4.     public static void main(String[] args) { 
  5.         A a = new A();
  6.         System.out.println("11-3=" + a.func1(11, 3));
  7.         System.out.println("1-8=" + a.func1(1, 8));
  9.         System.out.println("-----------------------");
  10.         B b = new B();
  11.         //因为 B 类不再继承 A 类，因此调用者，不会再 func1 是求减法
  12.         //调用完成的功能就会很明确
  13.         System.out.println("11+3=" + b.func1(11, 3));//这里本意是求出 11+3
  15.         System.out.println("1+8=" + b.func1(1, 8));// 1+8
  16.         System.out.println("11+3+9=" + b.func2(11, 3));
  19.         //使用组合仍然可以使用到 A 类相关方法
  20.         System.out.println("11-3=" + b.func3(11, 3));// 这里本意是求出 11-3
  23.     }
  24. }
  26. //创建一个更加基础的基类
  27. class Base { 
  28.     //把更加基础的方法和成员写到 Base 类
  29. }
  31. // A 类
  32. class A extends Base { 
  33.     // 返回两个数的差
  34.     public int func1(int num1, int num2) { 
  35.         return num1 - num2;
  36.     }
  37. }
  39. // B 类继承了 A
  40. // 增加了一个新功能：完成两个数相加,然后和 9 求和
  41. class B extends Base { 
  42.     //如果 B 需要使用 A 类的方法,使用组合关系
  43.     private A a = new A();
  45.     //这里，重写了 A 类的方法, 可能是无意识
  46.     public int func1(int a, int b) { 
  47.         return a + b;
  48.     }
  51.     public int func2(int a, int b) { 
  52.         return func1(a, b) + 9;
  53.     }
  55.     //我们仍然想使用 A 的方法
  56.     public int func3(int a, int b) { 
  57.         return this.a.func1(a, b);
  58.     }
  59. }

5、开闭原则

基本介绍

1、开闭原则（Open Closed Principle）是编程中最基础、最重要的设计原则。

2、一个软件实体如类，模块和函数应该对扩展开放(对提供方)，对修改关闭(对使用方)。用抽象构建框架，用实现扩展细节。

3、当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。

4、编程中遵循其它原则，以及使用设计模式的目的就是遵循开闭原则。

看一个画图形的功能

在这里插入图片描述

  1. package principle.ocp;
  3. public class Ocp { 
  4.     public static void main(String[] args) { 
  5.         //使用看看存在的问题
  6.         GraphicEditor graphicEditor = new GraphicEditor();
  7.         graphicEditor.drawShape(new Rectangle());
  8.         graphicEditor.drawShape(new Circle());
  9.         graphicEditor.drawShape(new Triangle());
  10.     }
  11. }
  13. //这是一个用于绘图的类 [使用方]
  14. class GraphicEditor { 
  15.     //接收 Shape 对象，然后根据 type，来绘制不同的图形
  16.     public void drawShape(Shape s) { 
  17.         if(s.m_type==1)
  18.             drawRectangle(s);
  19.         else if(s.m_type==2)
  20.             drawCircle(s);
  21.         else if(s.m_type==3)
  22.             drawTriangle(s);
  23.     }
  25.     //绘制矩形
  26.     public void drawRectangle(Shape r){ 
  27.         System.out.println(" 绘制矩形 ");
  28.     }
  30.     //绘制圆形
  31.     public void drawCircle(Shape r){ 
  32.         System.out.println(" 绘制圆形 ");
  33.     }
  35.     //绘制三角形
  36.     public void drawTriangle(Shape r){ 
  37.         System.out.println(" 绘制三角形 ");
  38.     }
  39. }
  41. //Shape 类，基类
  42. class Shape { 
  43.     int m_type;
  44. }
  47. class Rectangle extends Shape { 
  48.     Rectangle() { 
  49.         super.m_type = 1;
  50.     }
  51. }
  54. class Circle extends Shape { 
  55.     Circle() { 
  56.         super.m_type = 2;
  57.     }
  58. }
  60. //新增画三角形
  61. class Triangle extends Shape { 
  62.     Triangle() { 
  63.         super.m_type = 3;
  64.     }
  65. }

方式 1 的优缺点

  1. 优点是比较好理解，简单易操作。
  2. 缺点是违反了设计模式的 ocp 原则，即对扩展开放(提供方)，对修改关闭(使用方)。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码.
  3. 比如我们这时要新增加一个图形种类 三角形，修改的地方较多

改进的思路分析

思路：把创建 Shape 类做成抽象类，并提供一个抽象的 draw 方法，让子类去实现即可，这样我们有新的图形种类时，只需要让新的图形类继承 Shape，并实现 draw 方法即可，使用方的代码就不需要修 => 满足了开闭原则

  1. package principle.ocp.improve;
  3. public class Ocp { 
  4.     public static void main(String[] args) { 
  5.         //使用看看存在的问题
  6.         GraphicEditor graphicEditor = new GraphicEditor();
  7.         graphicEditor.drawShape(new Rectangle());
  8.         graphicEditor.drawShape(new Circle());
  9.         graphicEditor.drawShape(new Triangle());
  10.         graphicEditor.drawShape(new OtherGraphic());
  11.     }
  13. }
  15. //这是一个用于绘图的类 [使用方]
  16. class GraphicEditor { 
  17.     //接收 Shape 对象，调用 draw 方法
  18.     public void drawShape(Shape s) { 
  19.         s.draw();
  20.     }
  21. }
  23. //Shape 类，基类
  24. abstract class Shape { 
  25.     int m_type;
  26.     public abstract void draw();//抽象方法
  27. }
  29. class Rectangle extends Shape { 
  30.     Rectangle() { 
  31.         super.m_type = 1;
  32.     }
  34.     @Override
  35.     public void draw() { 
  36.         System.out.println(" 绘制矩形 ");
  37.     }
  38. }
  40. class Circle extends Shape { 
  41.     Circle() { 
  42.         super.m_type = 2;
  43.     }
  45.     @Override
  46.     public void draw() { 
  47.         System.out.println(" 绘制圆形 ");
  48.     }
  49. }
  51. //新增画三角形
  52. class Triangle extends Shape { 
  53.     Triangle() { 
  54.         super.m_type = 3;
  55.     }
  57.     @Override
  58.     public void draw() { 
  59.         System.out.println(" 绘制三角形 ");
  60.     }
  61. }
  63. //新增一个图形
  64. class OtherGraphic extends Shape { 
  65.     OtherGraphic() { 
  66.         super.m_type = 4;
  67.     }
  69.     @Override
  70.     public void draw() { 
  71.         System.out.println(" 绘制其它图形 ");
  72.     }
  73. }

6、迪米特法则

基本介绍

  1. 一个对象应该对其他对象保持最少的了解
  2. 类与类关系越密切，耦合度越大
  3. 迪米特法则(Demeter Principle)又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供的 public 方法，不对外泄露任何信息
  4. 迪米特法则还有个更简单的定义：只与直接的朋友通信
  5. 直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖，关联，组合，聚合等。其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。

应用实例

有一个学校，下属有各个学院和总部，现要求打印出学校总部员工 ID 和学院员工的 id

  1. package principle.demeter;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. //客户端
  7. public class Demeter1 { 
  9.     public static void main(String[] args) { 
  10.         //创建了一个 SchoolManager 对象
  11.         SchoolManager schoolManager = new SchoolManager();
  12.         //输出学院的员工 id 和 学校总部的员工信息
  13.         schoolManager.printAllEmployee(new CollegeManager());
  15.     }
  17. }
  19. //学校总部员工类
  20. class Employee { 
  21.     private String id;
  23.     public void setId(String id) { 
  24.         this.id = id;
  25.     }
  27.     public String getId() { 
  28.         return id;
  29.     }
  30. }
  32. //学院的员工类
  33. class CollegeEmployee { 
  34.     private String id;
  36.     public void setId(String id) { 
  37.         this.id = id;
  38.     }
  41.     public String getId() { 
  42.         return id;
  43.     }
  44. }
  46. //管理学院员工的管理类
  47. class CollegeManager { 
  48.     //返回学院的所有员工
  49.     public List<CollegeEmployee> getAllEmployee() { 
  50.         List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
  51.         for (int i = 0; i < 10; i++) {  //这里我们增加了 10 个员工到 list
  52.             CollegeEmployee emp = new CollegeEmployee(); emp.setId("学院员工 id= " + i);
  53.             list.add(emp);
  54.         }
  55.         return list;
  56.     }
  57. }
  59. //学校管理类
  61. //分析 SchoolManager 类的直接朋友类有哪些 Employee、CollegeManager
  62. //CollegeEmployee 不是直接朋友 而是一个陌生类，这样违背了 迪米特法则
  63. class SchoolManager { 
  64.     //返回学校总部的员工
  65.     public List<Employee> getAllEmployee() { 
  66.         List<Employee> list = new ArrayList<Employee>();
  68.         for (int i = 0; i < 5; i++) {  //这里我们增加了 5 个员工到 list
  69.             Employee emp = new Employee();
  70.             emp.setId("学校总部员工 id= " + i);
  71.             list.add(emp);
  72.         }
  73.         return list;
  74.     }
  76.     //该方法完成输出学校总部和学院员工信息(id)
  77.     void printAllEmployee(CollegeManager sub) { 
  79.         //分析问题
  80.         //1. 这里的 CollegeEmployee 不是 SchoolManager 的直接朋友
  81.         //2. CollegeEmployee 是以局部变量方式出现在 SchoolManager
  82.         //3. 违反了 迪米特法则
  84.         //获取到学院员工
  85.         List<CollegeEmployee> list1 = sub.getAllEmployee();
  86.         System.out.println("------------学院员工------------");
  87.         for (CollegeEmployee e : list1) { 
  88.             System.out.println(e.getId());
  89.         }
  90.         //获取到学校总部员工
  91.         List<Employee> list2 = this.getAllEmployee();
  92.         System.out.println("------------学校总部员工------------");
  93.         for (Employee e : list2) { 
  94.             System.out.println(e.getId());
  95.         }
  96.     }
  97. }

应用实例改进

1、前面设计的问题在于 SchoolManager 中，CollegeEmployee 类并不是 SchoolManager 类的直接朋友 (分析)

2、按照迪米特法则，应该避免类中出现这样非直接朋友关系的耦合

3、对代码按照迪米特法则 进行改进

  1. package principle.demeter.improve;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class Demeter1 { 
  7.     public static void main(String[] args) { 
  8.         System.out.println("~~~使用迪米特法则的改进~~~");
  9.         //创建了一个 SchoolManager 对象
  10.         SchoolManager schoolManager = new SchoolManager();
  11.         //输出学院的员工 id 和 学校总部的员工信息
  12.         schoolManager.printAllEmployee(new CollegeManager());
  14.     }
  16. }
  18. //学校总部员工类
  19. class Employee { 
  20.     private String id;
  21.     public void setId(String id) { 
  22.         this.id = id;
  23.     }
  24.     public String getId() { 
  25.         return id;
  26.     }
  27. }
  29. //学院的员工类
  30. class CollegeEmployee { 
  31.     private String id;
  33.     public void setId(String id) { 
  34.         this.id = id;
  35.     }
  37.     public String getId() { 
  38.         return id;
  39.     }
  40. }
  42. //管理学院员工的管理类
  43. class CollegeManager { 
  44.     //返回学院的所有员工
  45.     public List<CollegeEmployee> getAllEmployee() { 
  46.         List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
  47.         for (int i = 0; i < 10; i++) {  //这里我们增加了 10 个员工到 list
  48.             CollegeEmployee emp = new CollegeEmployee();
  49.             emp.setId("学院员工 id= " + i); list.add(emp);
  50.         }
  51.         return list;
  52.     }
  54.     // 输 出 学 院 员 工 的 信 息
  55.     public void printEmployee() { 
  56.         //获取到学院员工
  57.         List<CollegeEmployee> list1 = getAllEmployee();
  58.         System.out.println("------------学院员工------------");
  59.         for (CollegeEmployee e : list1) { 
  60.             System.out.println(e.getId());
  61.         }
  62.     }
  63. }
  65. //学校管理类
  67. //分析 SchoolManager 类的直接朋友类有哪些 Employee、CollegeManager
  68. //CollegeEmployee 不是 直接朋友 而是一个陌生类，这样违背了 迪米特法则
  69. class SchoolManager { 
  70.     //返回学校总部的员工
  71.     public List<Employee> getAllEmployee() { 
  72.         List<Employee> list = new ArrayList<Employee>();
  74.         for (int i = 0; i < 5; i++) {  //这里我们增加了 5 个员工到 list
  75.             Employee emp = new Employee();
  76.             emp.setId("学校总部员工 id= " + i); list.add(emp);
  77.         }
  78.         return list;
  79.     }
  81.     //该方法完成输出学校总部和学院员工信息(id)
  82.     void printAllEmployee(CollegeManager sub) { 
  84.         //分析问题
  85.         //1. 将输出学院的员工方法，封装到 CollegeManager
  86.         sub.printEmployee();
  88.         //获取到学校总部员工
  89.         List<Employee> list2 = this.getAllEmployee();
  90.         System.out.println("------------学校总部员工------------");
  91.         for (Employee e : list2) { 
  92.             System.out.println(e.getId());
  93.         }
  94.     }
  95. }

迪米特法则注意事项和细节

  • 迪米特法则的核心是降低类之间的耦合
  • 但是注意：由于每个类都减少了不必要的依赖，因此迪米特法则只是要求降低类间(对象间)耦合关系， 并不是要求完全没有依赖关系

7、合成复用原则（Composite Reuse Principle）

基本介绍

原则是尽量使用合成/聚合的方式，而不是使用继承

在这里插入图片描述

三、设计原则核心思想

1、找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

2、针对接口编程，而不是针对实现编程。

3、为了交互对象之间的松耦合设计而努力

发表评论

表情：
评论列表 （有 0 条评论，270人围观）

还没有评论，来说两句吧...

相关阅读

    相关 设计模式-七大原则

    1.设计模式的目的 设计模式是为了让程序(软件)， 具有更好 1. 代码重用性 (即： 相同功能的代码， 不用多次编写) 2. 可读性 (即： 编程规范性, 便于其

    向右看齐向右看齐/ 0 赞/ 221 阅读

    相关 设计模式七大原则

    引言 设计模式如单例模式、工厂模式、适配器模式等，大概有二十多种，但是这些设计模式的背后，有七大设计基本原则。 它们分别是：单一职责原则，接口隔离原则，依赖倒转原则，里

    妖狐艹你老母妖狐艹你老母/ 0 赞/ 103 阅读

    相关 设计模式七大原则

    　　我们在开发过程中常常使用设计模式 但使用设计模式时候 我们又是否知道设计模式的一些设计原则呢？ 今天我们就来盘一下设计模式七大原则，它们分别是： 　　1.开闭原则 　　

    àì夳堔傛蜴生んèńàì夳堔傛蜴生んèń/ 0 赞/ 404 阅读