设计模式七大原则

　　《设计模式七大原则》单一职责原则：
　　接口隔离原则：（Interface Segregation Principle）。
　　依赖倒转原则：（Dependence Inversion Principle）。
　　里氏替换原则：Liskov Substitution Principle。
　　开闭原则：Open Closed Principle 。
　　迪米特原则：（Demeter Principle）又叫最少知道原则。
　　合成复用原则：composite Resuse Principle）。
　　》》本文首发与公众号》》水啾的Java笔记。本文由本地MD比较直接粘贴而来，不想重新排版，如果发现有排版问题，请评论指出。好困啊… 〇、 概述1、参考视频
　　参考视频：https://www.bilibili.com/video/BV1gJ411X7uN?p=6&t=991.1 2、设计模式的目的
　　目的： 代码重用性。 可读性。 可扩展性。 可靠性。 使程序呈现高内聚、低耦合的特性。 3、设计原则核心思想找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。 针对接口编程，而不是针对实现编程。 为了交互对象之间的松耦合设计。 一、单一职责原则：1、单一职责原则介绍
　　单一职责原则：对类来说的，即一个类应该只负责一项职责。如果类A负责两个不同的职责：职责1、职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为A1、A2 。 2、代码演示
　　案例：交通工具。  //违法了单一职责原则。  package cn.sj.DesignPatterns.oopPrinciplesSeven;    /**   * Author gzm   * Date 2022/3/13/0013 22:51   * Version 1.0   * Description：oop七大原则之单一职责原则   **/  public class SingleResponsibility {      public static void main(String[] args) {          Vehicle vehicle = new Vehicle();          //以下显然是不合理的。          vehicle.run(＂摩托车＂);//摩托车在公路上跑          vehicle.run(＂轮船＂);//轮船在公路上跑          vehicle.run(＂飞机＂);//飞机在公路上跑      }  }    //交通工具类，  //违法了单一职责原则。应该分解该类。或者增加方法，不同类型工具对应不同的方法  class Vehicle{      public void run(String vehicle){          System.out.println(vehicle+＂在公路上跑＂);      }  }    //分解Vehicle类，符合单一职责原则。  class Roadvehicle{/*run...*/}  class AirVehicle{/*run...*/}  class WaterVehicle{/*run...*/}3、注意事项和细节降低类的复杂度，一个类只负责一项职责。 提高类的可读性、可维护性。 降低变更引起的风险。 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违法单一职责原则：只有类中的方法数量足够少，可以在方法级别保持单一职责原则。 二、接口隔离原则：1、基本介绍：
　　接口隔离原则（Interface Segregation Principle） 客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。
　　一张图：
　　类A通过接口Interface1依赖类B，类C通过接口Interface1依赖类D，如果接口Interface1对于类A和类C来说不是最小接口，那么类B和类D必须去实现它们不需要的方法。
　　按隔离原则应当这样处理：将接口Interface1拆分为独立的几个接口，类A和类C分别于它们需要的接口建立依赖关系。也就是采用＂接口隔离原则＂。 2、演示代码
　　演示不符合接口隔离原则  package cn.sj.DesignPatterns.oopPrinciplesSeven.interfaceSegregation;    /**   * 演示不满足接口隔离原则   * Author gzm   * Date 2022/4/09/0009 8:58   * Version 1.0   * Description：   **/  public class InterfaceSegregationPrinciple {      public static void main(String[] args) {          A a = new A();          Interface1 interface1_B = new B();          a.depend1(interface1_B);          a.depend2(interface1_B);          a.depend3(interface1_B);            D d = new D();          Interface1 interface1_C = new C();          d.depend3(interface1_C);          d.depend4(interface1_C);          d.depend5(interface1_C);        }  }    interface Interface1 {      void operation1();      void operation2();      void operation3();      void operation4();      void operation5();  }    class B implements Interface1 {      @Override      public void operation1() {System.out.println(＂B种的1方法。＂);}      @Override      public void operation2() {System.out.println(＂B种的2方法。＂);}      @Override      public void operation3() {System.out.println(＂B种的3方法。＂);}      @Override      public void operation4() {System.out.println(＂B种的4方法。＂);}      @Override      public void operation5() {System.out.println(＂B种的5方法。＂);}  }    class C implements Interface1 {      @Override      public void operation1() {System.out.println(＂C种的1方法。＂);}      @Override      public void operation2() {System.out.println(＂C种的2方法。＂);}      @Override      public void operation3() {System.out.println(＂C种的3方法。＂);}      @Override      public void operation4() {System.out.println(＂C种的4方法。＂);}      @Override      public void operation5() {System.out.println(＂C种的5方法。＂);}  }    /**   * A类通过接口interface1依赖（使用）到B类中的1、2、3 方法。   */  class A {      public void depend1(Interface1 interface1 ){interface1.operation1();}      public void depend2(Interface1 interface1 ){interface1.operation2();}      public void depend3(Interface1 interface1 ){interface1.operation3();}  }  /**   * D类通过接口interface1依赖（使用）到C类中的3、4、5 方法。   */  class D {      public void depend4(Interface1 interface1 ){interface1.operation4();}      public void depend5(Interface1 interface1 ){interface1.operation5();}      public void depend3(Interface1 interface1 ){interface1.operation3();}  }
　　改进为符合接口隔离原则：将接口1拆分。
　　三、依赖倒转原则：1、基本介绍
　　依赖倒转原则（Dependence Inversion Principle），也叫依赖倒置原则，是指： 高层模块不应该依赖底层模块，二者都应该依赖其抽象。 抽象不应该依赖细节，细节应该依赖抽象。 依赖倒转（倒置）的中心思想是 面向接口编程 依赖倒装原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定得多。以抽象为基础搭建的架构比以细节为基础的架构要稳定得多。在java中，抽象指的是接口或抽象类，细节就是具体地实现类。 使用接口或抽象类的目的是指定好规范，而不涉及任何具体的操作，把展现细节的任务交给它们的实现类去完成。 2、代码演示 package cn.sj.DesignPatterns.oopPrinciplesSeven;    /**   * 演示不符合依赖倒转原则   * Author gzm   * Date 2022/4/09/0009 10:52   * Version 1.0   * Description：   **/  public class DependenceInversion {      public static void main(String[] args) {          System.out.println(＂方式1，不符合依赖倒转原则＂);          Person1 person1 = new Person1();          person1.receive(new Email1());  //方式1不符合依赖倒转原则的电子右键信息…          System.out.println(＂============================＂);          System.out.println(＂方式2，符合依赖倒转原则＂);          Person2 person2 = new Person2();          person2.receive(new Email2());  //方式2，符合依赖倒转原则的电子右键          person2.receive(new WeXin());  //方式2，符合依赖倒转原则的微信      }  }    class Email1{      public String getInfo(){          return ＂方式1不符合依赖倒转原则的电子右键信息…＂;      }  }    /**   * 方式1，比较简单，但是不稳定。如果要接受信息的来源是微信或者短信，那么Person也要增加响应的方法。   */  class Person1{      public void receive(Email1 email){          System.out.println(email.getInfo());      }  }    /**   * 方式2 ，引入一个接口IReceive，类Person2与接口IReceive发生依赖。Email、WeXin等各自实现IReceive接口。   */  interface IReceive{      String getInfo();  }  class Email2 implements IReceive{      @Override      public String getInfo() {          return ＂方式2，符合依赖倒转原则的电子右键＂;      }  }  class WeXin implements IReceive{      @Override      public String getInfo(){          return ＂方式2，符合依赖倒转原则的微信＂;      }  }  class Person2{      public void receive(IReceive iReceive){          System.out.println(iReceive.getInfo());      }  }  3、依赖关系传递的三种方式3.1 接口传递 //接口传递    /**  * 开关的接口  */  interface IOpenAndClose {      public void open(ITV tv);//抽象方法，接收接口  }    /*  * ITV接口  */  interface ITV {      public void play();  }    /**  * 实现接口  */  class OpenAndCloseImpl implements IOpenAndClose {      public void open(ITV tv){          tv.play();      }  }3.2 构造方法传递 package cn.sj.DesignPatterns.oopPrinciplesSeven;    /**   * 构造方法传递   *   * Author gzm   * Date 2022/4/09/0009 11:32   * Version 1.0   * Description：   **/  public class ThreeTypesDependencies {      public static void main(String[] args) {          OpenAndCloseImpl openAndClose = new OpenAndCloseImpl(new ITV() {              @Override              public void play() {                  System.out.println(＂开关接口＂);              }          });          openAndClose.open();      }  }    /**   * 开关的接口   */  interface IOpenAndClose {      public void open();  }    /*   * ITV接口   */  interface ITV {      public void play();  }    /**   * 实现接口   */  class OpenAndCloseImpl implements IOpenAndClose {      private ITV tv;      public OpenAndCloseImpl(ITV tv){          this.tv = tv;      }        public void open(){          tv.play();          System.out.println(＂构造方法传递＂);      }  }3.3 setter方式传递 //通过setter方式传递    /**   * 开关的接口   */  interface IOpenAndClose {      public void open();      public void setTv(ITV tv);  }    /*   * ITV接口   */  interface ITV {      public void play();  }    /**   * 实现接口   */  class OpenAndCloseImpl implements IOpenAndClose {      private ITV tv;      public void setTv(ITV tv){          this.tv = tv;      }      public void open(){          tv.paly();      }  }  4 依赖倒转原则的注意事项和细节底层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好。 变量的声明类型尽量是抽象类或接口，这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序扩展和优化。 Fu obj = new new Zi  。继承时遵循里斯替换原则。 四、里氏替换原则：1、OOP中的继承性的思考和说明继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范，虽然它不能强制要求所有的子类必须遵循这些规范，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏。 继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加对象间的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到的子类的功能都有可能产生故障。 那么在继承中，如何正确的使用击沉？==》 里氏替换原则 。 2、里氏替换原则介绍里氏替换原则，Liskov Substitution Principle。 如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都替换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。换句话说，所有引用基类的地方必须能透明地使用其子类地对象。 在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法。 继承实际上让两个类的耦合性增强了，在适当的情况下，可以通过聚合、组合、依赖来解决 问题。 3、代码演示
　　一个没有遵循里斯替换原则的代码  package cn.sj.DesignPatterns.oopPrinciplesSeven;    /**   * 一个没有遵循里氏替换原则的例子   *   * Author gzm   * Date 2022/4/11/0011 22:03   * Version 1.0   **/  public class NoLisKov {        public static void main(String[] args){          A a = new A();          System.out.println(＂11-3=＂ + a.fun1(11,3));          System.out.println(＂12-9=＂ + a.fun1(12,8));            B b = new B();          System.out.println(＂11-3=＂ + b.fun1(11,3));          System.out.println(＂12-9=＂ + b.fun1(12,8));          System.out.println(＂11+3+9=＂ + b.fun2(11,3));      }  }    class A {      public int fun1(int num1, int num2){          return num1 - num2 ;      }  }    class B extends A {      public int fun1(int a ,int b){          return a + b;      }      public int fun2(int a ,int b){          return fun1(a,b) + 9;      }  }
　　修改为遵循里氏替换原则的代码：  package cn.sj.DesignPatterns.oopPrinciplesSeven;    /**   * 说明：一个遵循了里氏替换原则的例子   * B类不要继承A类，而是采用组合、集合、依赖。   * Author gzm   * Date 2022/4/11/0011 22:29   * Version 1.0   **/  public class IsLisKov {      //因为B类不再继承A类，因此调用者调用方法时就会很明确要调用谁。  }    class Bass {    }  class A2 extends Bass {      public int fun1(int num1, int num2){          return num1 - num2 ;      }  }    class B2 extends Bass {      //组合。      private final A2 a2= new A2();      public int fun3(int a, int b){          return this.a2.fun1(a,b);      }        public int fun1(int a ,int b){          return a + b;      }      public int fun2(int a ,int b){          return fun1(a,b) + 9;      }  }  五、开闭原则：1、基本介绍开闭原则，Open Closed Principle ，是编程中最基础、最重要的设计原则。 一个程序实体如类，模块和函数应该对扩展开放【对提供方来说的】、对修改关闭【对使用方来说的】。用抽象构建框架，用实现扩展细节。 当程序需要变化时，尽量通过扩展程序实体的行为来实现变化，而不是通过修改已有的代码来实现变化。 编程中遵循其他原则，以及使用设计模式的目的就是遵循开闭原则。 2、代码演示代码1，一个没有遵循开闭原则的例子。
　　优点是比较容易理解，简单易操作。
　　缺点是违反了设计模式的ocp原则。比如要增加一个图形类，就需要在代码中修改较多的地方。 package cn.sj.DesignPatterns.oopPrinciplesSeven;  /**  * 说明：一个没有遵循开闭原则的例子  * 
  * Author gzm  * Date 2022/4/12/0012 22:27  * Version 1.0  **/ public class NoOpenClosedPrinciple {     public static void main(String[] args) {         GraphicEditor graphicEditor = new GraphicEditor();         graphicEditor.drawShape(new Rectangle());         graphicEditor.drawShape(new Circle());     } }  /**  * 这是一个用于绘图的类，使用方。  */ class GraphicEditor{     //接收 Shape 对象，然后根据Shape的子类绘出不同的图形。     public void drawShape(Shape shape){         if (shape.m_type == 1){             drawRectangle(shape);         }else if(shape.m_type == 2){             drawCircle(shape);         }     }     public void drawRectangle(Shape shape){         System.out.println(＂绘制矩形＂);     }     public void drawCircle(Shape shape){         System.out.println(＂绘制圆形＂);     }     //如果要增加新功能比如增加一个新图形，就要大修代码。 }  /**  * 基类，提供者之一  */ class Shape{     int m_type; }  /**  * 矩形，提供者之一  */ class Rectangle extends Shape {     Rectangle(){         super.m_type = 1;     } }  /**  * 圆形，提供者之一  */ class Circle extends Shape{     Circle(){         super.m_type = 2;     } }
　　改进的思路：把创建  Shape  类做成抽象类，并提供一个抽象的方法draw方法，让子类去实现即可。这样当我们需要新的图形时，只需要让新的图形类继承 Shape  ，并实现draw  方法即可，使用方的代码就不需要修改 。package cn.sj.DesignPatterns.oopPrinciplesSeven;  /**  * 说明：一个遵循开闭原则的例子，是 NoOpenClosedPrinciple 的改进.  * 
  * Author gzm  * Date 2022/4/12/0012 22:56  * Version 2.0  **/ public class IsOpenClosedPrinciple {     public static void main(String[] args) {         GraphicEditor2 graphicEditor2 = new GraphicEditor2();         graphicEditor2.drawShape2(new Rectangle2());         graphicEditor2.drawShape2(new Circle2());         graphicEditor2.drawShape2(new Triangle2());     } } /**  * 这是一个用于绘图的类，使用者。  */ class GraphicEditor2{     //接收 Shape 对象，然后根据Shape的子类绘出不同的图形。     public void drawShape2(Shape2 shape){         shape.draw();     }  }  /**  * 基类，提供者之一  */ abstract class Shape2{     int m_type;      public abstract void draw(); }  /**  * 矩形，提供者之一  */ class Rectangle2 extends Shape2 {     Rectangle2(){         super.m_type = 1;     }      @Override     public void draw() {         System.out.println(＂实现基类Shape2中的抽象方法绘制了矩形。＂);     } }  /**  * 圆形，提供者之一  */ class Circle2 extends Shape2{     Circle2(){         super.m_type = 2;     }      @Override     public void draw() {         System.out.println(＂实现基类Shape2中的抽象方法绘制了圆形。＂);     } }  /**  * 新增的三角形，提供者之一  */ class Triangle2 extends Shape2{      @Override     public void draw() {         System.out.println(＂实现基类Shape2中的抽象方法绘制了三角形。＂);     } }3、开闭原则的细节六、迪米特法则：1、基本介绍一个对象应该对其他对象保持最少的了解。 类与类关系越密切，耦合度越大。 迪米塔法则（Demeter Principle）又叫最少知道原则。即一个类对自己依赖的类知道的越少越好。也就是说，对于依赖的类不管多复杂，都尽量将逻辑封装在类的内部。对外除了提供的public方法，不对外泄露任何信息。 迪米特法则还有个更简单的定义：只与直接的朋友通信。 直接的朋友【directFriends】：只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖、关联、组合、聚合等。其中，我们称出现在成员变量、方法参数、方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。也就是说，陌生的朋友不要以局部变量的形式出现在类的内部。 2、代码演示
　　有一个学校，下属有各个学院和总部，现要求打印出学校总部员工ID和学院员工的id。 package cn.sj.DesignPatterns.oopPrinciplesSeven;  import java.util.ArrayList; import java.util.List;  /**  * 说明：一个不符合迪米特法则的例子。  * 
  * Author gzm  * Date 2022/4/13/0013 22:17  * Version 1.0  **/ public class NoDemeterPrinciple {     public static void main(String[] args) {         SchoolManager schoolManager = new SchoolManager();         schoolManager.printAllEmployee(new CollegeManager());     } }  /**  * 学校总部员工。  */ class Employee{     private String id;     public void setId(String id){         this.id = id;     }     public String getId(){         return id;     } }  /**  * 学院员工  */ class CollegeEmployee{     private String id;     public void setId(String id){         this.id = id;     }     public String getId(){         return id;     } }  /**  * 管理学院员工的管理类。  */ class CollegeManager{     public List getAllEmployee(){         //返回学院的所有员工。         List list = new ArrayList();         for (int i = 0; i < 10; i++) {             CollegeEmployee emp = new CollegeEmployee();             emp.setId(＂学院员工id= ＂+i);             list.add(emp);         }         return list;     } }  /**  * 学校管理类  */ class SchoolManager{     public List getAllEmployee(){         List list = new ArrayList();         for (int i = 0; i < 5; i++) {             Employee emp = new Employee();             emp.setId(＂学校总部员工id= ＂+i);             list.add(emp);         }         return list;     }      //CollegeEmployee 不是 SchoolManager 的直接朋友。出现在局部变量中，违反了迪米特法则。     public void printAllEmployee(CollegeManager sub){         List list1 = sub.getAllEmployee();         System.out.println(＂------学院员工-------＂);         for (CollegeEmployee e : list1) {             System.out.println(e.getId());         }          List list2 = this.getAllEmployee();         System.out.println(＂------学校总部员工-------＂);         for (Employee e : list2) {             System.out.println(e.getId());         }      } }
　　改进：将输出学院员工的方法封装到学院员工管理类中。 你怎么做的，你去做就可以了，你不用让我知道你怎么做。 3、迪米特法则的注意事项迪米特法则的核心是降低类之间的耦合。 但是注意：由于每个类都减少了不必要的依赖，因此迪米特法则只是要求降低类的耦合关系，并不是要求完全没有依赖关系。 七、合成复用原则：
　　合成复用原则（composite Resuse Principle）：尽量使用合成、聚合的方式，而不是继承。