七大设计原则

一、开闭原则

开闭原则是指一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。可以提高软件系统的可复用性及可维护性。开闭原则，是面向对象设计中最基础的设计原则。
以商品为例：

/**
 * 商品通用接口
 */
public interface IShangPin {

    String getName();//名字
    Double getPrice();//价格
}

创建一个商品类实现商品接口

public class ShangPin implements IShangPin{

    private String name;
    private Double price;

    public ShangPin(String name, Double price) {
        this.name = name;
        price = price;
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public Double getPrice() {
        return this.price;
    }
}

通过main方法可以获取商品的原价和名称。

public class test {
    public static void main(String[] args) {
        IShangPin pin = new ShangPin("茅台", 3000.0);
        System.out.println("商品名称："+ pin.getName()+ "   商品价格："+ pin.getPrice());
        //运行结果：商品名称：茅台   商品价格：3000.0
    }
}

如果对固定商品打折，我们不可能在原来的基础上进行折扣，那样会影响其他的商品价格。

public class MaoTai extends ShangPin{

    public MaoTai(String name, Double price) {
        super(name, price);
    }

    public Double getPrice(){
        //茅台打95折
        return super.getPrice() * 0.95;
    }
}

通过main方法可以获取商品的折后价和名称。

public class test {
    public static void main(String[] args) {
        IShangPin maoTai = new MaoTai("茅台", 3000.0);
        System.out.println("商品名称："+ maoTai.getName()+ "   折后价格："+ maoTai.getPrice());
        //运算结果：商品名称：茅台   折后价格：2850.0
    }
}

代码结构图：

二、依赖倒置原则

依赖倒置原则是指设计代码结构时，高层模块不应该依赖底层模块，二者都应该依赖其抽象。抽象不应该依赖细节：细节应该依赖抽象。通过依赖倒置，可以减少类与类直接的耦合性，提高系统的稳定性，提高代码的可读性和可维护性，并降低修改程序所造成的风险。
接下来已课程为例，先创建一个类Tom：

public class Tom {
    public void studyJavaCourse(){
        System.out.println("Tom在学习Java课程");
    }
    public void studyPythonCourse(){
        System.out.println("Tom在学习Python课程");
    }
}

调用方法

public class test {
    public static void main(String[] args) {
        Tom tom = new Tom();
        tom.studyJavaCourse();
        tom.studyPythonCourse();
    }
}

Tom目前正在学java课程和python课程，如果Tom还想学习其他课程，我们的代码就要从底层到高层(调用层)一次修改代码，会给代码带来意想不到的风险。
接下来优化代码，创建一个课程抽象ICourse接口：

public interface ICourse {
    void study();
}

然后写JavaCourse类：

public class JavaCourse implements ICourse{

    @Override
    public void study() {
        System.out.println("Tom在学习Java课程");
    }
}

再写PythonCourse类：

public class PythonCourse implements ICourse{

    @Override
    public void study() {
        System.out.println("Tom在学习Python课程");
    }
}

修改Tom类：

public class Tom{
	public void study(ICourse course){
		course.study();
	}
}

看main方法：

public class test {
    public static void main(String[] args) {
        Tom tom = new Tom();
        tom.study(new JavaCourse());
        tom.study(new PythonCourse());
    }
}

对于新课程，只需要新建一个类，通过传参的方法告诉Tom，而不需要修改底层代码。实际上这是一种非常熟悉的方法，叫依赖注入。注入的方式还有构造器方式和setter方式。
切记：以抽象为基准比以细节为基准搭建起来的架构要稳定得多，因此大家拿到需求之后，要面向接口编程，先顶层再细节来设计代码的结构。

三、单一职责原则

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

四、接口隔离原则

接口隔离原则是指用多个专门的接口，而不使用单一的总接口，客服端不应该依赖它不需要的接口。这个原则指导我们在设计接口时应当注意一下己点：

1. 一个类对一个类的依赖应该建立在最小接口之上。
2. 建立单一接口，不要建立庞大臃肿的接口。
3. 尽量细化接口，接口中的方法尽量少（不是越少越好，一定要适度）。
   接口原则符合我们常说的高内聚低耦合的设计思想，从而使得类具有很好的可读性、可扩展性和可维护性。

五、迪米特原则

迪米特原则是指一个对象应该对其它对象保持最少的了解，又叫最少知道原则，尽量降低类与类之间的耦合。

六、里氏替换原则

里氏替换原则是指一个软件实体如果适用于一个父类的话，那么一定是适用于其子类，所有引用父类的地方必须能透明地使用其子类的对象，子类对象能替换父类对象，而逻辑不变。根据这个理解，我们总结一下：
引申含义：子类可以扩展父类的功能，但不能改变父类原有的功能。

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

七、合成复用原则

合成复用原则（Composite Reuse Principle，CRP）又叫组合/聚合复用原则（Composition/Aggregate Reuse Principle，CARP）。它要求在软件复用时，要尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。

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