维护性、扩展性、兼容性 里氏替换原则，继承必须确保超类所拥有的性质在子类中依然成立

    一流公司做标准，二流公司做产品，三流公司做销售

    里氏替换原则 - 图1

    1. public abstract class BankCard {
    3.     private Logger logger = LoggerFactory.getLogger(BankCard.class);
    5.     private String cardNo;   // 卡号
    6.     private String cardDate; // 开卡时间
    8.     public BankCard(String cardNo, String cardDate) {
    9.         this.cardNo = cardNo;
    10.         this.cardDate = cardDate;
    11.     }
    13.     abstract boolean rule(BigDecimal amount);
    15.     // 正向入账，+ 钱
    16.     public String positive(String orderId, BigDecimal amount) {
    17.         // 入款成功，存款、还款
    18.         logger.info("卡号{} 入款成功，单号：{} 金额：{}", cardNo, orderId, amount);
    19.         return "0000";
    20.     }
    22.     // 逆向入账，- 钱
    23.     public String negative(String orderId, BigDecimal amount) {
    24.         // 入款成功，存款、还款
    25.         logger.info("卡号{} 出款成功，单号：{} 金额：{}", cardNo, orderId, amount);
    26.         return "0000";
    27.     }
    29.     /**
    30.      * 交易流水查询
    31.      *
    32.      * @return 交易流水
    33.      */
    34.     public List<String> tradeFlow() {
    35.         logger.info("交易流水查询成功");
    36.         List<String> tradeList = new ArrayList<String>();
    37.         tradeList.add("100001,100.00");
    38.         tradeList.add("100001,80.00");
    39.         tradeList.add("100001,76.50");
    40.         tradeList.add("100001,126.00");
    41.         return tradeList;
    42.     }
    44.     public String getCardNo() {
    45.         return cardNo;
    46.     }
    48.     public String getCardDate() {
    49.         return cardDate;
    50.     }
    51. }
    1. public class CashCard extends BankCard {
    3.     private Logger logger = LoggerFactory.getLogger(CashCard.class);
    5.     public CashCard(String cardNo, String cardDate) {
    6.         super(cardNo, cardDate);
    7.     }
    9.     boolean rule(BigDecimal amount) {
    10.         return true;
    11.     }
    13.     /**
    14.      * 提现
    15.      *
    16.      * @param orderId 单号
    17.      * @param amount  金额
    18.      * @return 状态码 0000成功、0001失败、0002重复
    19.      */
    20.     public String withdrawal(String orderId, BigDecimal amount) {
    21.         // 模拟支付成功
    22.         logger.info("提现成功，单号：{} 金额：{}", orderId, amount);
    23.         return super.negative(orderId, amount);
    24.     }
    26.     /**
    27.      * 储蓄
    28.      *
    29.      * @param orderId 单号
    30.      * @param amount  金额
    31.      */
    32.     public String recharge(String orderId, BigDecimal amount) {
    33.         // 模拟充值成功
    34.         logger.info("储蓄成功，单号：{} 金额：{}", orderId, amount);
    35.         return super.positive(orderId, amount);
    36.     }
    38.     /**
    39.      * 风险校验
    40.      *
    41.      * @param cardNo  卡号
    42.      * @param orderId 单号
    43.      * @param amount  金额
    44.      * @return 状态
    45.      */
    46.     public boolean checkRisk(String cardNo, String orderId, BigDecimal amount) {
    47.         // 模拟风控校验
    48.         logger.info("风控校验，卡号：{} 单号：{} 金额：{}", cardNo, orderId, amount);
    49.         return true;
    50.     }
    52. }
    1. public class CreditCard extends CashCard {
    3.     private Logger logger = LoggerFactory.getLogger(CreditCard.class);
    5.     public CreditCard(String cardNo, String cardDate) {
    6.         super(cardNo, cardDate);
    7.     }
    9.     boolean rule2(BigDecimal amount) {
    10.         return amount.compareTo(new BigDecimal(1000)) <= 0;
    11.     }
    13.     /**
    14.      * 提现，信用卡贷款
    15.      *
    16.      * @param orderId 单号
    17.      * @param amount  金额
    18.      * @return 状态码
    19.      */
    20.     public String loan(String orderId, BigDecimal amount) {
    21.         boolean rule = rule2(amount);
    22.         if (!rule) {
    23.             logger.info("生成贷款单失败，金额超限。单号：{} 金额：{}", orderId, amount);
    24.             return "0001";
    25.         }
    26.         // 模拟生成贷款单
    27.         logger.info("生成贷款单，单号：{} 金额：{}", orderId, amount);
    28.         // 模拟支付成功
    29.         logger.info("贷款成功，单号：{} 金额：{}", orderId, amount);
    30.         return super.negative(orderId, amount);
    32.     }
    34.     /**
    35.      * 还款，信用卡还款
    36.      *
    37.      * @param orderId 单号
    38.      * @param amount  金额
    39.      * @return 状态码
    40.      */
    41.     public String repayment(String orderId, BigDecimal amount) {
    42.         // 模拟生成还款单
    43.         logger.info("生成还款单，单号：{} 金额：{}", orderId, amount);
    44.         // 模拟还款成功
    45.         logger.info("还款成功，单号：{} 金额：{}", orderId, amount);
    46.         return super.positive(orderId, amount);
    47.     }
    49. }