设计模式原则——里氏替换原则

已于 2024-06-24 16:11:46 修改
阅读量463 收藏 7
点赞数 4
分类专栏： 设计模式学习笔记 文章标签： 设计模式 里氏替换原则 java
于 2024-06-23 23:44:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luck_lsj/article/details/139908765
版权

设计模式原则

设计模式示例代码库地址：

https://gitee.com/Jasonpupil/designPatterns

里氏替换原则

  • 继承必须确保父类所拥有的性质在子类中依然成立

  • 与开闭原则不同的是开闭原则可以改变父类原有的功能，里氏替换原则不能修改父类的原有的性质，即使子类扩展了父类的功能，也不能改变父类的原有功能

  • 提高兼容性、维护性和扩展性

    • 子类和父类的接口保持一致，确保在任何使用父类的地方都可以替换为子类，而不会影响系统功能
    • 子类能够无缝地替换父类，替换时不需要修改客户端代码，方便地扩展新功能而不需要对现有代码进行大规模修改
    • 由于子类完全遵循父类的契约，系统在替换子类时不容易出现未预见的运行时错误

使用场景：银行卡存储，

  • 信用卡继承并重写储蓄卡的功能，破坏了里氏替换原则，根据里氏替换原则进行修改

里氏替换原则替换前示例代码：

储蓄卡类：
/**
 * @Description: 模拟储蓄卡功能
 * @Author: pupil
 * @Date: 2024/06/23 下午 10:04
 */
public class CashCard {

    private Logger logger = LoggerFactory.getLogger(CashCard.class);

    private static List<String> tradeList = new ArrayList<>();

    /**
     * 提现
     *
     * @param orderId 单号
     * @param amount  金额
     * @return 状态码 0000成功、0001失败、0002重复
     */
    public String withdrawal(String orderId, BigDecimal amount) {
        // 模拟支付成功
        logger.info("提现成功，单号：{} 金额：{}", orderId, amount);
        return "0000";
    }

    /**
     * 储蓄
     *
     * @param orderId 单号
     * @param amount  金额
     * @return 状态码 0000成功、0001失败、0002重复
     */
    public String recharge(String orderId, BigDecimal amount) {
        // 模拟充值成功
        logger.info("储蓄成功，单号：{} 金额：{}", orderId, amount);
        return "0000";
    }

    /**
     * 交易流水查询
     *
     * @return 交易流水
     */
    public List<String> tradeFlow() {
        logger.info("交易流水查询成功");
        tradeList.add("14451,100.00");
        tradeList.add("14451,65.00");
        tradeList.add("14451,76.50");
        tradeList.add("14451,126.00");
        return tradeList;
    }
}
信用卡类：
 /**
   * @Description: 模拟信用卡功能，重写父类的方法，违法里氏替换原则
   * @Author: pupil
   * @Date: 2024/06/23 下午 10:32
   */
  public class CreditCard extends CashCard{
  
      private Logger logger = LoggerFactory.getLogger(CashCard.class);
  
      /**
       * @param orderId 单号
       * @param amount  金额
       * @return 状态码 0000成功、0001失败、0002重复
       */
      @Override
      public String withdrawal(String orderId, BigDecimal amount) {
          // 校验
          if (amount.compareTo(new BigDecimal(1000)) >= 0){
              logger.info("贷款金额校验(限额1000元)，单号：{} 金额：{}", orderId, amount);
              return "0001";
          }
          // 模拟生成贷款单
          logger.info("生成贷款单，单号：{} 金额：{}", orderId, amount);
          // 模拟支付成功
          logger.info("贷款成功，单号：{} 金额：{}", orderId, amount);
          return "0000";
      }
  
      /**
       *
       * @param orderId 单号
       * @param amount  金额
       * @return 状态码 0000成功、0001失败、0002重复
       */
      @Override
      public String recharge(String orderId, BigDecimal amount) {
          // 模拟生成还款单
          logger.info("生成还款单，单号：{} 金额：{}", orderId, amount);
          // 模拟还款成功
          logger.info("还款成功，单号：{} 金额：{}", orderId, amount);
          return "0000";
      }
  
      @Override
      public List<String> tradeFlow() {
          return super.tradeFlow();
      }
  }
测试类：
/**
   * @Description: 验证测试
   * @Author: pupil
   * @Date: 2024/06/23 下午 10:33
   */
  public class ApiTest {
  
      private Logger logger = LoggerFactory.getLogger(ApiTest.class);
  
      @Test
      public void test_CashCard() {
          CashCard cashCard = new CashCard();
          // 提现
          cashCard.withdrawal("14451", new BigDecimal(100));
          // 储蓄
          cashCard.recharge("14451", new BigDecimal(100));
          // 交易流水
          List<String> tradeFlow = cashCard.tradeFlow();
          logger.info("查询交易流水，{}", JSON.toJSONString(tradeFlow));
      }
  
      @Test
      public void test_CreditCard() {
          CreditCard creditCard = new CreditCard();
          // 支付
          creditCard.withdrawal("14451", new BigDecimal(100));
          // 还款
          creditCard.recharge("14451", new BigDecimal(100));
          // 交易流水
          List<String> tradeFlow = creditCard.tradeFlow();
          logger.info("查询交易流水，{}", JSON.toJSONString(tradeFlow));
      }
  }
结果：
  • 在这里插入图片描述
  • 在这里插入图片描述

里氏替换原则替换后示例代码：

银行卡类：
/**
* @Description: 银行卡
* @Author: pupil
* @Date: 2024/06/23 下午 10:46
*/
public abstract class BankCard {

  private Logger logger = LoggerFactory.getLogger(BankCard.class);
  private static List<String> tradeList = new ArrayList<String>();

  private String cardId;   // 卡号
  private String cardDate; // 开卡时间

  public BankCard(String cardId, String cardDate) {
      this.cardId = cardId;
      this.cardDate = cardDate;
  }

  abstract boolean rule(BigDecimal amount);


  /**
   * 正向入账，+ 钱
   * @param orderId 单号
   * @param amount 金额
   * @return 状态码 0000成功、0001失败、0002重复
   */
  public String positive(String orderId, BigDecimal amount) {
      // 入款成功，存款、还款
      logger.info("卡号{} 入款成功，单号：{} 金额：{}", cardId, orderId, amount);
      return "0000";
  }

  /**
   * 逆向入账，- 钱
   * @param orderId
   * @param amount
   * @return 状态码 0000成功、0001失败、0002重复
   */
  public String negative(String orderId, BigDecimal amount) {
      // 入款成功，存款、还款
      logger.info("卡号{} 出款成功，单号：{} 金额：{}", cardId, orderId, amount);
      return "0000";
  }

  /**
   * 交易流水查询
   *
   * @return 交易流水
   */
  public List<String> tradeFlow() {
      logger.info("交易流水查询成功");
      tradeList.add("14451,100.00");
      tradeList.add("14451,80.00");
      tradeList.add("14451,76.50");
      tradeList.add("14451,126.00");
      return tradeList;
  }

  public String getCardId() {
      return cardId;
  }

  public String getCardDate() {
      return cardDate;
  }
}

/**
* @Description: 模拟储蓄卡功能
* @Author: pupil
* @Date: 2024/06/23 下午 10:04
*/
public class CashCard extends BankCard {

  private Logger logger = LoggerFactory.getLogger(CashCard.class);

  public CashCard(String cardNo, String cardDate) {
      super(cardNo, cardDate);
  }

  boolean rule(BigDecimal amount) {
      return true;
  }

  /**
   * 提现
   *
   * @param orderId 单号
   * @param amount  金额
   * @return 状态码 0000成功、0001失败、0002重复
   */
  public String withdrawal(String orderId, BigDecimal amount) {
      // 模拟支付成功
      logger.info("提现成功，单号：{} 金额：{}", orderId, amount);
      return super.negative(orderId, amount);
  }

  /**
   * 储蓄
   *
   * @param orderId 单号
   * @param amount  金额
   */
  public String recharge(String orderId, BigDecimal amount) {
      // 模拟充值成功
      logger.info("储蓄成功，单号：{} 金额：{}", orderId, amount);
      return super.positive(orderId, amount);
  }

}
信用卡类：
/**
* @Description: 模拟信用卡功能，重写父类的方法，违法里氏替换原则
* @Author: pupil
* @Date: 2024/06/23 下午 10:32
*/
public class CreditCard extends CashCard{

  private Logger logger = LoggerFactory.getLogger(CashCard.class);

  public CreditCard(String cardNo, String cardDate) {
      super(cardNo, cardDate);
  }

  /**
   * 金额规则
   * 根据里氏替换原则不能重写父类的rule方法，所以新构建一个方法
   * @param amount
   * @return
   */
  boolean rule2(BigDecimal amount) {
      return amount.compareTo(new BigDecimal(1000)) <= 0;
  }


  /**
   * 提现，信用卡贷款
   *
   * @param orderId 单号
   * @param amount  金额
   * @return 状态码 0000成功、0001失败、0002重复
   */
  public String loan(String orderId, BigDecimal amount) {
      boolean rule = rule2(amount);
      if (!rule) {
          logger.info("生成贷款单失败，金额超限。单号：{} 金额：{}", orderId, amount);
          return "0001";
      }
      // 模拟生成贷款单
      logger.info("生成贷款单，单号：{} 金额：{}", orderId, amount);
      // 模拟支付成功
      logger.info("贷款成功，单号：{} 金额：{}", orderId, amount);
      return super.negative(orderId, amount);

  }

  /**
   * 还款，信用卡还款
   *
   * @param orderId 单号
   * @param amount  金额
   * @return 状态码 0000成功、0001失败、0002重复
   */
  public String repayment(String orderId, BigDecimal amount) {
      // 模拟生成还款单
      logger.info("生成还款单，单号：{} 金额：{}", orderId, amount);
      // 模拟还款成功
      logger.info("还款成功，单号：{} 金额：{}", orderId, amount);
      return super.positive(orderId, amount);
  }
}
测试类：
/**
* @Description: 测试验证
* @Author: pupil
* @Date: 2024/06/23 下午 10:51
*/
public class ApiTest {

  private Logger logger = LoggerFactory.getLogger(ApiTest.class);

  @Test
  public void test_bankCard() {
      logger.info("里氏替换前，CashCard类：");
      CashCard bankCard = new CashCard("800999898", "2024-06-23");
      // 提现
      bankCard.withdrawal("14451", new BigDecimal(100));
      // 储蓄
      bankCard.recharge("14451", new BigDecimal(100));

      logger.info("里氏替换后，CreditCard类：");
      CashCard creditCard = new CreditCard("800999898", "2024-06-23");
      // 提现
      creditCard.withdrawal("14451", new BigDecimal(1000000));
      // 储蓄
      creditCard.recharge("14451", new BigDecimal(100));

      // 交易流水
      List<String> tradeFlow = bankCard.tradeFlow();
      logger.info("查询交易流水，{}", JSON.toJSONString(tradeFlow));
  }

  @Test
  public void test_CreditCard(){
      CreditCard creditCard = new CreditCard("800999898", "2024-06-23");
      // 支付，贷款
      creditCard.loan("14451", new BigDecimal(100));
      // 还款
      creditCard.repayment("14451", new BigDecimal(100));

      // 交易流水
      List<String> tradeFlow = creditCard.tradeFlow();
      logger.info("查询交易流水，{}", JSON.toJSONString(tradeFlow));
  }
}
结果：

  • 在这里插入图片描述

  • 在这里插入图片描述

根据里氏替换原则的示例类图：

在这里插入图片描述

银行卡和储蓄卡是泛化关系，储蓄卡继承于银行卡

储蓄卡和信用卡是泛化关系，信用卡继承于储蓄卡

ERoslon青年
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
24种设计模式介绍与6大设计原则
08-30
总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 二、设计模式的六大原则 1、开闭原则（Open Close Principle） 开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。 2、里氏代换原则（Liskov Substitution Principle） 里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科 3、依赖倒转原则（Dependence Inversion Principle） 这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。 4、接口隔离原则（Interface Segregation Principle） 这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。 5、迪米特法则（最少知道原则）（Demeter Principle） 为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。 6、合成复用原则（Composite Reuse Principle） 原则是尽量使用合成/聚合的方式，而不是使用继承。
设计模式六大原则 设计模式详解
08-05
2. 里氏替换原则（Liskov Substitution Principle，LSP）：子类必须能够替换其基类，而不影响程序的正确性。这意味着子类对象在任何基类适用的地方都可以被使用。 3. 依赖倒置原则（Dependency Inversion Principle...
设计模式七大原则——里氏替换原则
胜天半子祁同伟
02-06 6238
设计模式七大原则——里氏替换原则
java设计模式原则——里氏替换原则
u014627852的博客
06-13 915
设计模式回顾： 1.java设计模式 2.java设计模式原则——单一职责原则 3.java设计模式原则——接口隔离原则 4.java设计模式原则——依赖倒置原则 设计模式demo示例下载 OO 中的继承性的思考和说明 继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有 的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏。 继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低
Java设计原则——里氏替换原则
怪咖@的博客
02-14 686
OO（面向对象）中的继承性的思考和说明：基本介绍：以下示例就是继承父类，然后重新代码之后，不轻易间就会导致程序出现各种问题。 2、示例二 解决方法：这个示例就是利用组合关系来代替，这个Base基类是没放东西的，其含义是，将这两个类共用的放到这里面，这只是个例子，所以没写东西。...
设计模式系列（二）设计模式原则——里氏替换原则(Liskov Substitution Principle)
Jackie的博客
11-05 119
里氏替换原则用于规范类的继承，防止类父类的修改过多影响到子类而提出的一种设计原则。 里氏替换原则在1988年，由麻省理工学院的Liskov女士提出的。 如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序 P在所有的对象o1都代换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1 的子类型。所有引用基类的地方必须能透明地使用其子类的对象。 在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法 里氏替换原则告诉我们，继承实际上
设计模式——里氏替换原则
weixin_45417821的博客
08-20 413
里氏替换原则(Liskov Substitution Principle)在 1988 年，由麻省理工学院的以为姓里的女士提出的。如果对每个类型为 T1 的对象 o1，都有类型为 T2 的对象 o2，使得以 T1 定义的所有程序 P 在所有的对象 o1 都代换成 o2 时，程序 P 的行为没有发生变化，那么类型 T2 是类型 T1 的子类型。换句话说，所有引用基类的地方必须能透明地使用其子类的对象。在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法。
里氏替换原则——面向对象设计原则
qq_41854911的博客
05-24 550
在上一节《开闭原则》中，我们详细介绍了开闭原则，本节我们来介绍里式替换原则。 里氏替换原则的定义 里氏替换原则（Liskov Substitution Principle，LSP）由麻省理工学院计算机科学实验室的里斯科夫（Liskov）女士在 1987 年的“面向对象技术的高峰会议”（OOPSLA）上发表的一篇文章《数据抽象和层次》（Data Abstraction and Hierarchy）里提出来的，她提出：继承必须确保超类所拥有的性质在子类中仍然成立（Inheritance should ensur
设计原则之贰——里氏替换原则
yuiezt的专栏
02-11 181
里氏替换原则是继承复用的基础，它反映了基类与子类之间的关系，是对开闭原则的补充，是对实现抽象化的具体步骤的规范。
【设计原则2】——里氏替换原则
未闻花名
03-12 224
里氏替换原则 定义 1.通俗来说，子类可以扩展父类的功能，但是不能改变父类原有的功能。 2.在程序中将一个父类对象替换成子类对象，程序将不会产生任何错误和异常，反过来不成立。 3.它是实现开闭原则的重要方式之一，由于使用基类对象的地方都可以使用子类对象，程序中尽量使用父类类型来定义对象，运行时再确立子类类型，用子类对象替换父类对象。 里氏替换原则包含的含义 1.子类可以实现父类的抽象方法，但是不能覆盖父类的非抽象方法。 2.子类可以增加自己特有的方法。 3.当子类覆盖或实现父类方法时，方法前置条件（形参）要
PHP设计模式概论【概念、分类、原则等】
10-15
设计模式并不是一种新技术，而是软件设计经验的结晶，它基于面向对象编程原则，如开闭原则（Open-Closed Principle）、里氏替换原则（Liskov Substitution Principle）、依赖倒置原则（Dependency Inversion ...
设计模式Demo
11-09
二、设计模式的六大原则 1、开闭原则（Open Close Principle） 开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序...
Java23种基本的设计模式整料整理学习源码示例zip
05-08
设计模式的六大原则 开闭原则（Open Close Principle） 开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好...
七大原则——里氏替换原则
热门推荐
m0_37654408的博客
04-09 1万+
里氏替换原则的定义 里氏替换原则（Liskov Substitution Principle，LSP）由麻省理工学院计算机科学实验室的里斯科夫（Liskov）女士在 1987 年的“面向对象技术的高峰会议”（OOPSLA）上发表的一篇文章《数据抽象和层次》（Data Abstraction and Hierarchy）里提出来的，她提出：继承必须确保超类所拥有的性质在子类中仍然成立（Inherit...
设计模式之过滤器模式
努力的小雨，一个阳光向上的博客不仅仅给你知识更希望带给你快乐
06-24 273
博主上次分析完cas客户端源码后，发现了其实就是一个过滤器模式，对请求以及session一直做校验，每个过滤器都有各自的工作，互不影响耦合性低，所以就模仿其源码，做了一次过滤器模式的学习，图示如下。好了，我们来看一下过滤器模式，一个过滤器接口定义方法，多个实现类去实现具体操作过滤，一个整合类增加一个过滤器，一个过滤器链表去实现以节点类型，依次进行过滤。9 * 他说，哪年树弯了腰，人见了老，桃花落了白发梢，他讲的笑话她还会笑，那便是好。7 * 旧巷里有一个穿着白衬衫笑起来如太阳般温暖我的少年。
设计模式——工厂方法模式
橘猫的博客
06-23 361
工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它定义了一个用于创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让一个类的实例化延迟到其子类。
实验08 软件设计模式及应用
最新发布
m0_51371779的博客
06-24 755
在多个裁判负责打分的比赛中,每位裁判给选手一个得分,选手的最后得分是根据全体裁判的得分计算出来的。请给出几种计算选手得分的评分方案（策略）,对于某次比赛,可以从你的方案中选择一种方案作为本次比赛的评分方案。用户家里现有一台洗衣机，洗衣机使用交流电，现在用户新买了一台录音机，录音机只能使用直流电。由于供电系统供给用户家里的是交流电，因此用户需要用适配器将交流电转化直流电供录音机使用。过程如下：先捏泥巴成人形，再放入八卦炉里烤，最后扔到地上成长。时间烤短了，造出了“白种人”；时间烤长了，造出了“黑种人”；
设计模式原则——单一职责原则（SPS）
luck_lsj的博客
06-22 950
设计模式原则——单一职责原则（SPS）
Java面试题-设计模式+设计原则+代理.pdf
06-12
Java面试题-设计模式+设计原则+代理.pdf

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值