一、六大设计原则
- 开闭原则
- 依赖倒置原则
- 单一职责原则
- 接口隔离原则
- 迪米特法则(最少知道原则)
- 里氏替换原则
二、开闭原则
- 定义:一个软件实体如类、模块和函数应该对扩展开放,对修改关闭
- 用抽象构建框架,用实现扩展细节
- 优点:提高软件系统的可复用性和可维护性
如上图,接口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());
}
}
在写代码的时候,我们需要注意区别哪些是“朋友”,哪些是“陌生人”,遵循好迪米特原则。
七、里氏替换原则
- 定义:所有引用基类的地方必须能透明化地使用其子类的对象
- 即子类可以扩展父类的功能,但是不能改变父类原有的功能。也就是说,在子类继承父类的时候,除了添加新的方法完成新增功能之外,尽量不要重写父类的方法
- 子类可以实现父类的抽象方法,但是不能覆盖父类的非抽象方法
- 子类中可以增加自己特有的方法
- 当子类的方法重载父类的方法时,方法的前置条件(即方法的形参)要比父类方法的输入参数更加宽松