软件设计的七大原则
一、开闭原则
定义：一个软件实体如类、模块函数应该对扩展开放，对修改关闭。强调的是用抽象构建框架，用实现扩展细节。以提高软件系统的可复用性及可维护性帮助我们实现稳定灵活的系统架构。生活中的实例（弹性工作制，每天必须工作满八小时这个是不能修改的，但是对于什么时候来什么时候走没有规定）。实现开闭原则的核心思想是面向抽象编程。
代码场景：web应用通常是有过滤器的，通常有很多个，每个都是一类功能的集合，一般我们只是通过继承 Filter 新增实现类的方式去添加新的过滤器来丰富我们的功能，而不是在原来的过滤器上做修改，将新的功能添加进去。这种就是对扩展开放，对修改关闭。
二、依赖倒置原则
定义：高层模块不应该依赖低层模块，二者都应该依赖其抽象。抽象不应该依赖细节；细节应该依赖抽象。针对接口编程，不要针对实现编程。通过抽象包括使用接口或者抽象类，可以使个各类或者模块的实现彼此独立，互不影响，从而实现模块间的耦合性。简单来说就是程序应该依赖于接口而不是实现类。
优点：可以减少类间的耦合性、提高系统稳定性、提高代码可读性和维护性，可降低修改程序所造成的风险。
代码场景：Geely 在慕课网上学习，对 Java 课程比较感兴趣，对 前端 课程也感兴趣，那么按照面向实现的编程就是有个Geely实体类有两个方法：1.学习 Java 的方法；2. 学习 前端 的方法。
/**
* Geely 类 => 低层模块
*/
public class Geely {
public void studyJavaCourse(){
System.out.println("Geely 在学习 Java 课程");
}
public void studyFECourse(){
System.out.println("Geely 在学习 FE 课程");
}
}
======================
/**
* 测试类 <=> 应用层 => 高层模块
*/
public class Test {
public static void main(String[] args) {
Geely geely = new Geely();
geely.studyFECourse();
geely.studyJavaCourse();
}
}
现在假如我还要学习 Python 课程，那么需要改变的就是在 Geely 类添加关于学习 Python 的方法，如果还要学习其他的课程那么方那么这个 Geely 类是一直在补充变化的，这违背开闭原则。上述的过程也是面向实现编程的过程，扩展性比较差。而且Test测试类的使用需要依赖 Geely 类，Test 想调用学习 哪门课程 的方法，Geely 类就要添加这个方法才能调用，息息相关。
/**
* Geely 类
*/
public class Geely {
public void studyJavaCourse(){
System.out.println("Geely 在学习 Java 课程");
}
public void studyFECourse(){
System.out.println("Geely 在学习 FE 课程");
}
// 新增关于学习 Python 的方法
public void studyPythonCourse(){
System.out.println("Geely 在学习 Python 课程");
}
}
通过引入 抽象类/接口 来解决上述问题：Geely 类一直在变化，怎么做到 Geely 不变，只通过改变最底层的方法和应用层的调用方法来达到想学什么课程就学什么课程。
/**
* Icourse 接口,里面定义了一个学习课程的方法
*/
public interface Icourse {
public void studyCourse();
}
/**
* Icourse 接口实现类，具体学习哪门课程
*/
public class FECourse implements Icourse {
public void studyCourse() {
System.out.println("Geely 在学习 FE 课程");
}
}
/**
* Icourse 接口实现类，具体学习哪门课程
*/
public class JavaCourse implements Icourse {
public void studyCourse() {
System.out.println("Geely 在学习 Java 课程");
}
}
/**
* Geely 类,通过一个自定义方法 studyImoocCourse ，将 Icourse 的实现类传入
*/
public class Geely {
// public void studyJavaCourse(){
// System.out.println("Geely 在学习 Java 课程");
// }
//
// public void studyFECourse(){
// System.out.println("Geely 在学习 FE 课程");
// }
//
// public void studyPythonCourse(){
// System.out.println("Geely 在学习 Python 课程");
// }
private Icourse icourse;
public Geely() {
}
// V4 通过 setter 注入
public void setIcourse(Icourse icourse) {
this.icourse = icourse;
}
// 通过构造器注入，可以将原来定义的带参的方法，将其变为无参方法即可
public Geely(Icourse icourse) {
this.icourse = icourse;
}
// V1 带参方法，Test 调用传入即可
// V2 变为无参，通过构造方法注入
public void studyImoocCourse(/*Icourse icourse*/){
icourse.studyCourse();
}
}
/**
* 测试类
*/
public class Test {
// V1 面向实现编程
// public static void main(String[] args) {
// Geely geely = new Geely();
// geely.studyFECourse();
// geely.studyJavaCourse();
// }
// V2 面向接口编程，通过调用方法传入参数方式
// public static void main(String[] args) {
// Geely geely = new Geely();
// geely.studyImoocCourse(new JavaCourse());
// geely.studyImoocCourse(new FECourse());
// }
// V3 面向接口编程，通过构造器注入的方式调用方法，缺点，每新学一个课程就要new一下
// public static void main(String[] args) {
// Geely geely = new Geely(new JavaCourse());
// geely.studyImoocCourse();
// geely = new Geely(new FECourse());
// geely.studyImoocCourse();
// }
// V4 面向接口编程，通过 setter 注入的方式，调用方法
// public static void main(String[] args) {
// Geely geely = new Geely();
// JavaCourse javaCourse = new JavaCourse();
// geely.setIcourse(javaCourse);
// geely.studyImoocCourse();
// }
}
类关系图
Test 是应用层模块属于高层模块， Geely 是 Test 的低层，
可以发现，Test 的调用不再依赖 Geely 的改变而实现相应的调用，再扩展的时候只需要新增 ICourse 接口的实现类，在 Test 里面调用方法传入即可，并不需要改变 Geely 类，也符合开闭原则。
三、单一职责原则
定义：不要存在多于一个导致类变更的原因。例如某个类有了两个方法，每个方法负责一个职能，假如方法一的职责需要发生变化，那么就需要修改这个类文件，这种改变就可能导致原本运行正常的方法二发生故障。对于这种两个职责经常发生变化的方法，需要分别建立相应的 java 文件分别负责相应的职能，避免一方暂时改变另一方不变的情况下，相互影响。通常情况下我们对类单一职责要求较低，但是接口和方法尽量是保证单一职责。根据你的业务要求所写的类或者接口方法最好能满足需求即可，不需要对其进行可能会用到的扩展，如果真的有，那就再写一个方法、类、接口。
在java代码中的体现：一个类/接口/方法只负责一项职责。
优点：降低类的复杂度、提高类的可读性、提高系统的可维护性、降低变更引起的风险。
四、接口隔离原则
定义：用多个专门的接口，而不使用单一的总接口，客户端不应该依赖它不需要的接口。一个类对一个类的依赖应该建立在最小的接口上。建立单一的接口，不要建立庞大臃肿的接口。尽量细化接口，接口中的方法尽量少。注意适度原则。
上面这段话的意思就是，某个类可能只需要某个接口中的一个方法，但是该接口却有n多个他不需要的方法，如果实现这个接口那么就要实现该接口的所有定义的方法，这样是不对的，此时应该接口的方法独立为一个小的接口，或者新建一个包含该方法的接口。适度原则指的是，接口中的方法不能太少，如果太少的话那么就会产生多个接口，那么就会有很多的实现类导致整个系统类结构体系很庞大，系统可维护性变差。
优点：符合我们常说的高内聚低耦合的设计思想，从而使得类具有良好的可读性、可扩展性和可维护性。
五、迪米特法则
定义：一个对象应该对其他对象保持最少的了解，又叫最少知道原则。尽量降低类与类之间的耦合。高内聚低耦合的体现。
大概意思就是能自己解决的就不要去求别人。
强调只和朋友交流，不和陌生人说话。保持神秘
关于朋友的概念：出现在成员变量、方法输入、输出参数中的类称为朋友关系类，而出现在方法体内部的类不属于朋友类,所以这类实体类也是我们要避免的。
那么从类上面来说也需要进行自我的保护，也即类里面尽量减少对外公开的非 public 的方法、和非静态的 public 变量、成员变量 private 化，利用包权限和 protected 保护自己。
假如有这样一个场景，有一个方法放在A类也行，放在B类也行，那么如何去做？原则是：如果该方法放在本类中既不增加类间关系，也对本类不产生负面影响，那就可以放在本类中。对外部的类的引用越少越好。
优点：降低类之间的耦合。
Codding场景：慕课网是有大老板的，有一天跟一个 TeamLeader 说，你给我查一下，到现在为止线上有多少个课程，那这里面关系到几个类:Boss、TeamLeader、Course。Boss里面有对 TeamLeader 下指令的方法，TeamLeader 有统计线上课程的方法。
违背 DEMETER 法则的代码如下
import java.util.ArrayList;
import java.util.List;
/**
* Boss 类
* 根据 DEMETER 法则。该类里面为朋友关系的是 TeamLeader 类，
* 而 commandCheckNumber 方法体内部的 Course 类，
* 不算是朋友关系，陌生人，孤立他
* 这里 Boss 完全没有必要知道 Course 这个类，
* 他只需要知道 TeamLeader 这个类，并对他下指令获取线上课程 Course 即可
*/
public class Boss {
// 有一个对 TeamLeader 下指令的方法，查询线上课程的数量
public void commandCheckNumber(TeamLeader teamLeader){
//
List<Course> courseList = new ArrayList<Course>();
for (int i = 0; i < 20; i++) {
courseList.add(new Course());
}
teamLeader.checkNumberOfCourses(courseList);
}
}
import java.util.List;
/**
* TeamLeader 类
* 该类有统计 线上课程的方法
*/
public class TeamLeader {
public void checkNumberOfCourses(List<Course> courseList){
System.out.println("在线课程的数量是：" + courseList.size());
}
}
/**
* 被统计的课程
*/
public class Course {
}
/**
* Test 测试类
*/
public class Test {
public static void main(String[] args) {
Boss boss = new Boss();
TeamLeader teamLeader = new TeamLeader();
boss.commandCheckNumber(teamLeader);
}
}
类结构图如下：
正确的代码，将Boss 类里面创建 Course 集合的代码去掉，挪到 TeamLeader 里面，Test 和 Course 不变，代码和类结构图如下。
/**
* Boss 类
* 根据 DEMETER 法则。该类里面为朋友关系的是 TeamLeader 类，
* 而 commandCheckNumber 方法体内部的 Course 类，
* 不算是朋友关系，陌生人，孤立他
* 这里 Boss 完全没有必要知道 Course 这个类，
* 他只需要知道 TeamLeader 这个类，并对他下指令获取线上课程 Course 即可
*/
public class Boss {
// 有一个对 TeamLeader 下指令的方法，查询线上课程的数量
public void commandCheckNumber(TeamLeader teamLeader){
teamLeader.checkNumberOfCourses();
}
}
/**
* TeamLeader 类
* 该类有统计 线上课程的方法
*/
public class TeamLeader {
public void checkNumberOfCourses(){
//
List<Course> courseList = new ArrayList<Course>();
for (int i = 0; i < 20; i++) {
courseList.add(new Course());
}
System.out.println("在线课程的数量是：" + courseList.size());
}
}
PS：我们在写代码的时候需要想清楚，哪些类是直接的朋友，哪些不是。参考DEMETER法则来开发。
六、里式替换法则
定义：如果对每一个类型为 T1 的对象 o1，都有类型为 T2 的对象 o2，使得以 T1 定义的所有程序 P 在所有的对象 o1 都替换成 o2 时，程序 P 的行为没有发生变化，那么类型 T2 是类型 T1 的子类型。通过这个定义我们可以引申出来一个定义继承，T1 是 T2 的父类。里式替换原则是继承复用的基石，当子类可以替换父类，并且软件功能不受影响时，父类才能真正的被复用，子类也可以增加自己新的功能，里式替换原则是对开闭原则的一个补充，它是对实现抽象化的具体步骤规范。里式替换原则所表达的含义就是反对子类重写父类方法的这一含义。
定义扩展：一个软件实体如果适用一个父类的话，那么一定适用于其子类，所有引用父类的地方必须能透明的使用其子类的对象，子类对象能够替换父类对象，而程序逻辑不变。
引申意义：
1. 子类可以扩展父类的功能，但不能改变父类原有的功能。
含义1：子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。
含义2：子类可以增加自己特有的方法。
含义3：当子类的方法重载父类的方法时，方法的前置条件（即方法的输入/入参）要比父类方法的输入参数更宽松。
含义4：当子类的方法实现父类的方法时（重写/重载或实现抽象方法），方法的后置条件（即方法的输出/返回值）要比父类严格或相等。
优点：
1. 约束继承泛滥，开闭原则的一种体现。
2. 加强程序的健壮性，同时变更时也可以做到非常好的兼容性提高程序的可维护性、扩展性。降低需求变更时引入的风险。
Codding：
七、合成（组合）/聚合复用法则
定义：尽量使用对象组合/聚合，而不是继承关系达到软件复用的目的。
聚合 has-A和组合contains-A
优点：可以是系统更加灵活，降低类与类之间的耦合度，一个类的变化对其他类造成的影响相对较少。
何时使用合成/聚合、继承
聚合 has-A 关系
组合contains-A 包含关系
继承 is-A 父子关系
————————————————
原文链接：https://blog.csdn.net/qq_29676623/article/details/85530078
