软件设计六大原则

一、六大设计原则

• 开闭原则
• 依赖倒置原则
• 单一职责原则
• 接口隔离原则
• 迪米特法则（最少知道原则）
• 里氏替换原则

二、开闭原则

• 定义：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭
• 用抽象构建框架，用实现扩展细节
• 优点：提高软件系统的可复用性和可维护性
  
  如上图，接口ICourse定义了id、name、price，JavaCourse实现了它，现在需要获取到折扣价格，不能直接去修改ICourse接口以及JavaCourse基类（对修改关闭），应该新建一个JavaDiscountCourse继承JavaCourse去实现功能（对扩展开放）。

三、依赖倒置原则

• 定义：高层模块不应该依赖底层模块，二者都应该依赖其抽象
• 抽象不应该依赖细节；细节应该依赖抽象
• 针对接口编程，不要针对实现编程
• 优点：可以减少类间的耦合性、提高系统稳定性，提高代码可读性和可维护性，可降低修改程序所造成的风险

场景：Geely需要学习Java、python、C等课程

面向实现编程

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

public class Test {
    public static void main(String[] args) {
        Geely geely = new Geely();
        geely.studyCCourse();
        geely.studyJavaCourse();
        geely.studyPythonCourse();
    }

以上面向实现编程，当Geely想要学习其他课程，需要修改Geely类，同时Test类也要增加相应的代码。

面向接口编程

public interface Icourse {
    public void studyCourse();
}
 
public class CCourse implements Icourse {
    public void studyCourse() {
        System.out.println("Geely 在学习 C 课程");
    }
}
 
public class JavaCourse implements Icourse {
    public void studyCourse() {
        System.out.println("Geely 在学习 Java 课程");
    }
}
 
public class Geely {
    private  Icourse icourse;
 
    public Geely() {
    
    }
 
    //通过setter注入
    public void setIcourse(Icourse icourse) {
        this.icourse = icourse;
    }
 
    // 通过构造器注入
    public Geely(Icourse icourse) {
        this.icourse = icourse;
    }
 
    public void studyImoocCourse(Icourse icourse){
        icourse.studyCourse();
    }
}
 
public class Test {
 
    //方法传参
    public static void main(String[] args) {
        Geely geely = new Geely();
        geely.studyImoocCourse(new JavaCourse());
        geely.studyImoocCourse(new FECourse());
    }
 
    //通过构造器注入的方式调用方法
    public static void main(String[] args) {
        Geely geely = new Geely(new JavaCourse());
        geely.studyImoocCourse();
        geely = new Geely(new FECourse());
        geely.studyImoocCourse();
    }
 
      //通过setter注入的方式
      public static void main(String[] args) {
          Geely geely = new Geely();
          JavaCourse javaCourse = new JavaCourse();
          geely.setIcourse(javaCourse);
          geely.studyImoocCourse();
      }
}

Geely不依赖具体的Course，Geely想学任何课，可以不去改动Geely、ICourse，直接新建一个类实现ICourse。

四、单一职责原则

• 定义：不要存在多于一个导致类变更的原因
• 一个类/接口/方法只负责一项职责
• 优点：降低类的复杂度、提高类的可读性，提高系统的可维护性、降低变更引起的风险

五、接口隔离原则

• 定义：用多个专门的接口，而不使用单一的总接口，客户端不应该依赖它不需要的接口
• 一个类对一个类的依赖应该建立在最小的接口上
• 建立单一接口，不要建立庞大臃肿的接口
• 尽量细化接口，接口中的方法尽量少
• 注意适度原则，一定要适度
• 优点：符合我们常说的高内聚低耦合的设计思想，从而使得类具有很好的可读性、可扩展性和可维护性

六、迪米特原则

• 定义：一个对象应该对其他对象保持最少的了解，又叫最少知道原则
• 尽量降低类与类之间的耦合
• 优点：降低类之间的耦合
• 强调只和朋友交流，不和陌生人说话
• 朋友：出现在成员变量、方法的输入、输出参数中的类成为成员朋友类，而出现在方法内部的类不属于朋友类。

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);
    }
}
 
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想要课程数量，但是Boss又创建了Course类（陌生人），Boss应该只与TeamLeader交流（朋友：入参），TeamLeader应该直接返回结果。

public class Boss {
    public void commandCheckNumber(TeamLeader teamLeader){
        teamLeader.checkNumberOfCourses();
    }
}
 
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());
    }
}

在写代码的时候，我们需要注意区别哪些是“朋友”，哪些是“陌生人”，遵循好迪米特原则。

七、里氏替换原则

• 定义：所有引用基类的地方必须能透明化地使用其子类的对象
• 即子类可以扩展父类的功能，但是不能改变父类原有的功能。也就是说，在子类继承父类的时候，除了添加新的方法完成新增功能之外，尽量不要重写父类的方法
• 子类可以实现父类的抽象方法，但是不能覆盖父类的非抽象方法
• 子类中可以增加自己特有的方法
• 当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更加宽松