2020 11.20曾宇欣

设计模式的六大原则

  1. 开闭原则:

    • 开闭原则的意思是 对扩展开放,对修改关闭 。在程序需要进行扩展的时候,不能去修改原有的代码,简言之,是为了使程序的扩展性好,易于维护和升级。想要达到这样的效果,我们需要使用接口和抽象类,后面的具体设计中我们会提到这点
  2. 里氏替换原则:

    • 里氏替换原则主要阐述了有关继承的一些原则,也就是什么时候应该使用继承,什么时候不应该使用继承,以及其中蕴含的原理。里氏替换原是继承复用的基础,它反映了基类与子类之间的关系,是对开闭原则的补充,是对实现抽象化的具体步骤的规范

    • 里氏替换原则的作用

      1. 里氏替换原则是实现开闭原则的重要方式之一。
      2. 它克服了继承中重写父类造成的可复用性变差的缺点。
      3. 它是动作正确性的保证。即类的扩展不会给已有的系统引入新的错误,降低了代码出错的可能性。
      4. 加强程序的健壮性,同时变更时可以做到非常好的兼容性,提高程序的维护性、可扩展性,降低需求变更时引入的风险。
    • 里氏替换原则的实现方法

      • 里氏替换原则通俗来讲就是:子类可以扩展父类的功能,但不能改变父类原有的功能。

      • 子类可以实现父类的抽象方法,但不能覆盖父类的非抽象方法

      • 子类中可以增加自己特有的方法

      • 当子类的方法重载父类的方法时,方法的前置条件(即方法的输入参数)要比父类的方法更宽松

      • 当子类的方法实现父类的方法时(重写/重载或实现抽象方法),方法的后置条件(即方法的的输出/返回值)要比父类的方法更严格或相等

      //举例里氏替换原则在“企鹅不是鸟”实例中的应用
      //鸟类
      class Bird {
      int flySpeed;
      public void setSpeed(int speed){
      flySpeed = speed;
      }
      public int getFlyTime(int distance){
      return (distance / flyspeed);
      }
      }
      //燕子类
      class Swallow extends Bird{}
      //企鹅类
      class Penguin extends Bird{
      public void setSpeed(int speed)
      {
      flySpeed=0;
      }
      }
      public static void mian(String[] args){
      Bird b1 = new Swallow();
      Bird b2 = new Penguin();
      b1.setSpeed(120);
      b2.setSpeed(120);
      System.out.println("如果飞行300公里:");
      System.out.println("燕子将飞行"+bird1.getFlyTime(300)+"小时.");
      System.out.println("企鹅将飞行"+bird2.getFlyTime(300)+"小时。");
      }

      此程序会报错,企鹅重写了鸟类的setSpeed方法,这违背了里氏替换原则。正确的做法是取消企鹅的继承关系,定义鸟类和企鹅更一般的父类,比如动物类,他们都具有奔跑的能力。

  3. 依赖倒置原则

    依赖倒置原则的原始定义为:高层模块不应该依赖低层模块,两者都应该依赖其抽象;抽象不应该依赖细节,细节应该依赖抽象。其核心思想是:要面向接口编程,不要面向实现编程。

    • 依赖倒置原则的作用

      • 依赖倒置原则可以降低类间的耦合性。
      • 依赖倒置原则可以提高系统的稳定性。
      • 依赖倒置原则可以减少并行开发引起的风险。
      • 依赖倒置原则可以提高代码的可读性和可维护性。
    • 依赖倒置原则的实现方法

      依赖倒置原则的目的是通过要面向接口的编程来降低类间的耦合性。

      1.每个类尽量提供接口或抽象类,或者两者都具备。

      2.变量的声明类型尽量是接口或者抽象类。

      3.任何类都不应该从具体类派生。

      4.使用继承时尽量遵循里氏替换原则。

      //依赖倒置原则在“顾客购物程序”中的应用。
      public class DIPtest{
      public static void main(Stirng[] args){
      Customer c = new Customer();
      c.shop(new TaoBao());
      c.shop(new JingDong());
      }
      }
      interface Shop{
      public String sell();
      }
      class TaoBao implements Shop{
      public sell(){
      return "a,b,c";
      }
      }
      class JingDong implements Shop{
      public String sell(){
      return "d,e,f";
      }
      }
      class Customer{
      public void shopping(Shop shop){
      System.out.print(shop.sell());
      }
      }
  4. 单一职责原则

    单一职责原则规定一个类应该有且仅有一个引起它变化的原因,否则类应该被拆分。

  5. 接口隔离原则

    要为各个类建立它们需要的专用接口,而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。

    接口隔离原则的实现方法

    在具体应用接口隔离原则时,应该根据以下几个规则来衡量。

    • 接口尽量小,但是要有限度。一个接口只服务于一个子模块或业务逻辑。

    • 为依赖接口的类定制服务。只提供调用者需要的方法,屏蔽不需要的方法。

    • 了解环境,拒绝盲从。每个项目或产品都有选定的环境因素,环境不同,接口拆分的标准就不同深入了解业务逻辑。

    • 提高内聚,减少对外交互。使接口用最少的方法去完成最多的事情。

      // 学生成绩管理系统
      //学生成绩管理程序一般包含插入成绩、删除成绩、修改成绩、计算总分、计算均分、打印成绩信息、査询成绩信息等功能,如果将这些功能全部放到一个接口中显然不太合理,正确的做法是将它们分别放在输入模块、统计模块和打印模块等 3 个模块中
      public class ISPtest{
      public static void main(Stirng[] args){}
      }
      //输入模块接口
      interface InputModule{
      void insert();
      void delete();
      void modify();
      }
      //统计模块接口
      interface CountModule{
      void countTotalScore();
      void countAverage();
      }
      //打印模块接口
      interface PrintModule
      {
      void printStuInfo();
      void queryStuInfo();
      }
      //实现类
      class StuScoreList implements InputModule,CountModule,PrintModule{
      private StuScoreList(){
      InputModule input =StuScoreList.getInputModule();
      CountModule count =StuScoreList.getCountModule();
      PrintModule print =StuScoreList.getPrintModule();
      input.insert();
      count.countTotalScore();
      print.printStuInfo();
      }
      public static InputModule getInputModule()
      {
      return (InputModule)new StuScoreList();
      }
      public static CountModule getCountModule()
      {
      return (CountModule)new StuScoreList();
      }
      public static PrintModule getPrintModule()
      {
      return (PrintModule)new StuScoreList();
      }
      public void insert()
      {
      System.out.println("输入模块的insert()方法被调用!");
      }
      public void delete()
      {
      System.out.println("输入模块的delete()方法被调用!");
      }
      public void modify()
      {
      System.out.println("输入模块的modify()方法被调用!");
      }
      public void countTotalScore()
      {
      System.out.println("统计模块的countTotalScore()方法被调用!");
      }
      public void countAverage()
      {
      System.out.println("统计模块的countAverage()方法被调用!");
      }
      public void printStuInfo()
      {
      System.out.println("打印模块的printStuInfo()方法被调用!");
      }
      public void queryStuInfo()
      {
      System.out.println("打印模块的queryStuInfo()方法被调用!");
      }
      }
  6. 迪米特法则的定义

    如果两个软件实体无须直接通信,那么就不应当发生直接的相互调用,可以通过第三方转发该调用。其目的是降低类之间的耦合度,提高模块的相对独立性。

    //明星与经纪人的关系实例。
    public class LoDtest
    {
    public static void main(String[] args)
    {
    Agent agent=new Agent();
    agent.setStar(new Star("林心如"));
    agent.setFans(new Fans("粉丝韩丞"));
    agent.setCompany(new Company("中国传媒有限公司"));
    agent.meeting();
    agent.business();
    }
    }
    //经纪人
    class Agent{
    private Start myStart;
    private Fans myFans;
    private Company myCompany;
    public void setStart(String name){
    this.myStart = name;
    }
    public void setFans(String name){
    this.myFans = name;
    }
    public void setCompany(String name){
    this.myCompany = name;
    }
    public void meeting(){
    System.out.println(myFans.getName()+"与明星"+myStar.getName()+"见面了。");
    }
    public void business(){
    System.out.println(myCompany.getName()+"与明星"+myStar.getName()+"洽淡业务。");
    }
    }
    //明星
    class Star
    {
    private String name;
    Star(String name)
    {
    this.name=name;
    }
    public String getName()
    {
    return name;
    }
    }
    //粉丝
    class Fans
    {
    private String name;
    Fans(String name)
    {
    this.name=name;
    }
    public String getName()
    {
    return name;
    }
    }
    //媒体公司
    class Company
    {
    private String name;
    Company(String name)
    {
    this.name=name;
    }
    public String getName()
    {
    return name;
    }
    }
  7. 合成复用原则

    如果要使用继承关系,则必须严格遵循里氏替换原则。合成复用原则同里氏替换原则相辅相成的,两者都是开闭原则的具体实现规范。

标签

评论

© 2021 成都云创动力科技有限公司 蜀ICP备20006351号-1