设计原则

学习设计原则是学习设计模式的基础。在实际开发过程中，并不是一定要求所有代码都遵循设计原 则，我们希望代码在要在适当的场景遵循设计原则，帮助我们设计出更加优雅的代码结构。

开闭原则

一句话总结：在不改动原有代码的基础上，增加新功能。

开闭原则(Open-Closed Principle, OCP)是指一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。是对扩展和修改两个行为的一个原则。开闭原则，是面向对象设计中最基础的设计原 则。它指导我们如何建立稳定灵活的系统，例如:我们版本更新，尽可能不修改源代码，但是可以增加新功能。

以超市商品为例,首先创建一个商品接口：

public interface IGoods {
    Integer getId();
    String getName();
    Double getPrice();
}

商品种类有很多，举一辆汽车为例

public class CarGoods implements IGoods{
    private Integer Id;
    private String name;
    private Double price;
public CarGoods(Integer id, String name, Double price) { this.Id = id;
       this.name = name;
       this.price = price;
    }
    public Integer getId() {
       return this.Id;
    }
    public String getName() {
       return this.name;
    }
    public Double getPrice() {
       return this.price;
    }
}

现在要给车做活动，打个折。如果直接修改getPrice()方法，则会 存在一定的风险，可能影响其他地方的调用结果。我们如何在不修改原有代码前提前下，实现价格优惠 这个功能呢?现在，我们再写一个处理优惠逻辑的类，CarDiscount类:

public class CarDiscount extends JavaCourse {
    public CarDiscount(Integer id, String name, Double price) {
       super(id, name, price);
    }
  
    private Double discount;
    public Double getOriginPrice(){
       return super.getPrice();
    }
    public Double getPrice(){
       return super.getPrice() * discount;
    }
}

依赖倒置原则

一句话总结：要面向接口编程，不要面向实现编程。

依赖倒置原则(Dependence Inversion Principle,DIP)是指设计代码结构时，高层模块不应该依 赖底层模块，二者都应该依赖其抽象。让用户程序依赖于抽象，实现的细节也依赖于抽象。即使实现细节不断变动，只要抽象不变，客户程序就不需要变化。
例如，当我们要去买车的时候

public class CarBuyer{
    public void buyBenz(){
        System.out.println("Benz");
    }
    public void buyFord(){
        System.out.println("Ford");
    }
}


public static void main(String[] args) {
    CarBuyer tom = new CarBuyer();
    tom.buyBenz();
    tom.buyFord();
}

后来呢,Tom 开始玩车，又想去买更爽一点的车。。这个时候，业务扩展，我们的代码要从底层到高层(调用层)一次修改代码。这时候在CarBuyer增加新的方法时，在调用层中也要追加。如此一来，系统发布以后，实际上是非常不稳定的，在修改代码的同时也会带来意想不到的风险。

开始优化：

public interface IShopping{
    void buy();
}

public class BenzShopping() implements IShopping{
    @Override
     public void buy(){
      System.out.println("Benz");
  }
}

public class FordShopping() implements IShopping{
    @Override
     public void buy(){
      System.out.println("Ford");
  }
}

public class buyer{
      public void buyCar(IShopping shopping){
          shopping.buy()
      }
}

单一职责原则

一句话总结：一个类应该有且仅有一种职责。

单一职责(Simple Responsibility Pinciple，SRP)是指不要存在多于一个导致类变更的原因。假 设我们有一个 Class 负责两个职责，一旦发生需求变更，修改其中一个职责的逻辑代码，有可能会导致 另一个职责的功能发生故障。这样一来，这个 Class 存在两个导致类变更的原因。如何解决这个问题呢? 我们就要给两个职责分别用两个 Class 来实现，进行解耦。后期需求变更维护互不影响。这样的设计， 可以降低类的复杂度，提高类的可读性，提高系统的可维护性，降低变更引起的风险。总体来说就是一个Class/Interface/Method 只负责一项职责。

里式替换原则

一句话总结：子类可以扩展父类的功能，但不能改变父类原有的功能。

里氏替换原则(Liskov Substitution Principle,LSP)是指如果对每一个类型为 T1 的对象 o1,都有 类型为 T2 的对象 o2,使得以 T1 定义的所有程序 P 在所有的对象 o1 都替换成 o2 时，程序 P 的行为没 有发生变化，那么类型 T2 是类型 T1 的子类型。
看了一遍定义不知道在说什么东西。其实可以理解为如果适用一个父类的话， 那一定是适用于其子类，所有引用父类的地方必须能透明地使用其子类的对象，子类对象能够替换父类对象，而程序逻辑不变。子类可以扩展父类的功能，但不能改变父类原有的功能。

1. 子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。
2. 子类中可以增加自己特有的方法。
3. 当子类的方法重载父类的方法时，方法的前置条件(即方法的输入/入参)要比父类方法的输入
   参数更宽松。
4. 当子类的方法实现父类的方法时(重写/重载或实现抽象方法)，方法的后置条件(即方法的输
   出/返回值)要比父类更严格或相等。

显然在之前开闭原则时，我们重写了getPrice()方法，增加了一个获取源码的方法 getOriginPrice()，显然就违背了里氏替换原则。

使用里氏替换原则有以下优点:

1. 约束继承泛滥，开闭原则的一种体现。
2. 加强程序的健壮性，同时变更时也可以做到非常好的兼容性，提高程序的维护性、扩展性。降低 需求变更时引入的风险。

合成复用原则

一句话总结：减少继承，使用对象之间的调用。

合成复用原则(Composite/Aggregate Reuse Principle,CARP)是指尽量使用对象组合(has-a)/ 聚合(contanis-a)，而不是继承关系达到软件复用的目的。将已有对象纳入新对象中，使之成为新对象的一部分，新对象可以调用已有对象的功能。

继承我们叫做白箱复用，相当于把所有的实现细节暴露给子类。组合/聚合也称之为黑箱复用，对类以外的对象是无法获取到实现细节的。

我们已经封装好的类不希望暴露出来实现细节,使用合成复用将已有对象纳入新对象中，使之成为新对象的一部分，新对象可以调用已有对象的功能。

以数据库为例：

public class DBConnection {
    public String getConnection(){
return "MySQL 数据库连接"; }
}

public class ProductDao{
    private DBConnection dbConnection;
    public void setDbConnection(DBConnection dbConnection) {
       this.dbConnection = dbConnection;
    }
    public void addProduct(){
        String conn = dbConnection.getConnection(); System.out.println("使用"+conn+"增加产品");
    } 
}

软件复用时，要尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。

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

这 7 种设计原则是软件设计模式必须尽量遵循的原则，各种原则要求的侧重点不同。其中，开闭原则是总纲，它告诉我们要对扩展开放，对修改关闭；里氏替换原则告诉我们不要破坏继承体系；依赖倒置原则告诉我们要面向接口编程；单一职责原则告诉我们实现类要职责单一；接口隔离原则告诉我们在设计接口的时候要精简单一；迪米特法则告诉我们要降低耦合度；合成复用原则告诉我们要优先使用组合或者聚合关系复用，少用继承关系复用。