当前位置: 首页 > news >正文

大话设计模式:七大设计原则

目录

一、单一职责原则(‌Single Responsibility Principle, SRP)‌

二、开放封闭原则(‌Open-Closed Principle, OCP)

三、依赖倒置原则(‌Dependency Inversion Principle, DIP)

四、里氏替换原则(‌Liskov Substitution Principle, LSP)

五、接口隔离原则(‌Interface Segregation Principle, ISP)

六、合成复用原则(‌Composite Reuse Principle, CRP)

七、迪米特法则(‌Demeter Principle, DP)


设计模式的七大原则是软件设计和开发中的重要指导原则,‌它们帮助开发者创建可扩展、‌可维护和灵活的软件系统。‌这些原则包括:‌

  1. 单一职责原则(‌Single Responsibility Principle, SRP)‌:‌一个类应该只有一个引起变化的原因。‌这意味着每个类应该有一个明确的职责,‌并且仅负责完成一项功能,‌这样可以使类更加模块化和可维护。‌
  2. 开放封闭原则(‌Open-Closed Principle, OCP)‌:‌软件实体(‌如类、‌模块或函数)‌应该对扩展开放,‌对修改关闭。‌这意味着当软件需要适应新的环境或需求时,‌应该通过添加新的代码来扩展系统的行为,‌而不是修改现有的代码。‌
  3. 依赖倒置原则(‌Dependency Inversion Principle, DIP)‌:‌高层模块不应该依赖于低层模块,‌它们都应该依赖于抽象。‌抽象不应该依赖于细节,‌细节应该依赖于抽象。‌这意味着代码应该依赖于接口或抽象类,‌而不是具体的实现类。‌
  4. 里氏替换原则(‌Liskov Substitution Principle, LSP)‌:‌子类型必须能够替换其基类型而不会产生任何问题。‌这确保了继承关系的正确使用,‌子类应该能够保持与父类相同的接口和行为,‌从而保持系统的稳定性和可维护性。‌
  5. 接口隔离原则(‌Interface Segregation Principle, ISP)‌:‌客户端不应该依赖于它不需要的接口。‌这意味着接口应该被细分为更小的、‌更具体的接口,‌这样客户端只需要知道和使用它感兴趣的方法。‌
  6. 合成复用原则(‌Composite Reuse Principle, CRP)‌:‌优先使用对象组合而不是继承来达到复用的目的。‌这意味着在面向对象设计中,‌应该优先考虑通过组合或聚合关系来复用已有的设计和实现,‌而不是通过继承。‌
  7. 迪米特法则(‌Demeter Principle, DP)‌:‌一个对象应当仅与它的朋友(‌friendly objects)‌说话。‌这有助于减少对象之间的耦合,‌提高软件的可维护性和可读性。‌

遵循这些原则可以帮助开发人员创建更加灵活、‌可维护和可扩展的软件系统。

一、单一职责原则(‌Single Responsibility Principle, SRP)‌

 定义:一个类应该只有一个引起它变化的原因。

一个类 / 接口 / 方法只负责一项职责

优点:降低类的负责度、提高类的可读性,提高系统的可维护性、降低变更的风险。

public interface UserService {void updateUser(User user,int opt);
}

传入修改类型,用户名,去修改用户信息。但这里却违背了(单一职责原则)

改造方法:

public interface UserService {void changeName(String name);void changePwd(String pwd);
}

这种更符合我们单一职责原则。

但是我们开发的时候可能会有些迷茫,什么时候去划分,什么时候放到一起,那这个时候,就应该去重新审视代码,哪些是需要合并到一起,哪些是要应用。

这里的原则,既是最简单的原则,也是最难的原则,难的时候,可能我们不是特别好区分。

二、开放封闭原则(‌Open-Closed Principle, OCP)

定义:一个软件实体,例如类、模块、函数,应该对扩展是开放的,对修改是关闭的。

实现:用抽象构建框架,用实现扩展细节

优点:提高软件系统的可复用性及可维护性。

用例:

书籍实体:

public interface IBook {/*** 编号* @return*/Integer getId();/*** 名称* @return*/String getName();/*** 价格* @return*/Double getPrice();
}

书籍接口:

public class BookImpl implements IBook {private Integer id;private String name;private Double price;public BookImpl(Integer id, String name, Double price) {this.id = id;this.name = name;this.price = price;}@Overridepublic Integer getId() {return id;}@Overridepublic String getName() {return name;}@Overridepublic Double getPrice() {return price;}}

测试用例: 

public class Test {public static void main(String[] args) {DiscountBookImpl book = new DiscountBookImpl(1,"java", 100.0);System.out.println("Book Id: " + book.getId() + ", Title: " + book.getTitle() + ", Price: " + book.getPrice());}
}

假设我们来了业务需求,书籍打折,我们在原来的书籍接口上这样修改:

public class BookImpl implements IBook {private Integer id;private String name;private Double price;public BookImpl(Integer id, String name, Double price) {this.id = id;this.name = name;this.price = price;}@Overridepublic Integer getId() {return id;}@Overridepublic String getName() {return name;}@Overridepublic Double getPrice() {return this.price * 0.8;}}

这样本身就违背了我们这条原则,正确的做法应该是:

新建一个打折书籍接口

public class DiscountBookImpl extends BookImpl{public DiscountBookImpl(Integer id, String name, Double price, Double discount) {super(id, name, price);this.discount = discount;}@Overridepublic Double getPrice() {return super.getPrice() * 0.8;}public Double getOriginalPrice() {return super.getPrice();}
}

三、依赖倒置原则(‌Dependency Inversion Principle, DIP)

定义:程序要依赖于抽象接口,不要依赖于具体实现简单的说就是要求对抽象进行编程,不要对实现进行编程。 

面向过程的开发,上层调用下层,上层依赖于下层,当下层剧烈变动时上层也要跟着变动,这就会导致模块的复用性降低而大大提高了开发的成本。

面向对象的开发很好的解决了这个问题,一般情况下抽象的变化概率很小,让用户程序依赖于抽象,实现的细节也依赖于抽象。即使实现细节不断变动,只要抽象不变,客户程序就不需要变化。

优点:可以减少类间的耦合性,提高系统的稳定性,提高代码可读性和维护性,可降低修改程序所造成的风险。

用例:

学生实体:

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

学生学习课程:

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

降低耦合改造:

新建课程接口:

public interface ICourse {void study();
}

新建Java课程类:

public class JavaCourse implements ICourse {@Overridepublic void study(){System.out.println("JavaCourse study");}
}

新建Python类:

public class PythonCourse extends ICourse {@Overridepublic void study(){System.out.println("PythonCourse study");}
}

改造学生实现类:

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

改造测试类:

public class Test {public static void main(String[] args) {JavaCourse javaCourse = new JavaCourse();Student student = new Student();Student.study(javaCourse);}
}

改造之后,依赖于上层、下层通过接口访问。

改造2【利用Spring构造器依赖注入原理】

Student改造:

public class Student {ICourse course;public Student(ICourse course){this.course = course;}public void study(){course.study();}
}

测试类改造:

public class Test {public static void main(String[] args) {JavaCourse javaCourse = new JavaCourse();Student student = new Student(javaCourse);Student.study();}
}

改造3【利用Spring Set注入】

Student改造:

public class Student {ICourse course;public void setCourse(ICourse course){this.course = course;}public void study(){course.study();}
}

测试类改造:

public class Test {public static void main(String[] args) {JavaCourse javaCourse = new JavaCourse();Student student = new Student();student.setCourse(javaCourse);Student.study();}
}

备注:执行的过程是一样的

四、里氏替换原则(‌Liskov Substitution Principle, LSP)

定义:派生类(子类)对象可以在程式中替代其基类(超类)对象。

因为继承带来的侵入性,增加了耦合性,也降低了代码灵活性,父类修改代码,子类也会受到影响,此时就需要里氏替换原则。

  • 子类必须实现父类的抽象方法,但不得重写(覆盖)父类的非抽象(已实现)方法。【在java里面可以重写,但是不建议】
  • 子类中可以增加自己特有的方法。
  • 当子类覆盖或实现父类的方法时,方法的前置条件(即方法的形参)要比父类方法的输入参数更宽松。
  • 当子类的方法实现父类的抽象方法时,方法的后置条件(即方法的返回值)要比父类更严格。

用例:

父类:

public class Parent {public void method(int i){System.out.println("Parent method");}
}

子类:

public class Child extends Parent {@Overridepublic void method(int i){System.out.println("Child method");}
}

单元测试:

public class Test {public static void main(String[] args) {Parent p = new Parent();p.method(10);}
}

执行结果:

当改成子类时:

public class Test {public static void main(String[] args) {Parent p = new Child();p.method(10);}
}

用里氏替换原则进行调整。

父类:

public abstract class Parent {public List method(ArrayList i){return null;}public abstract ArrayList<String> method(List i);public abstract void abstractMethod(int i);
}

子类:

public class Child extends Parent {@Overridepublic ArrayList<String> method(List i){System.out.println("Child method");return null;}@Overridepublic void abstractMethod(int i) {}public void method2(int i){System.out.println("Child method2");}
}

优点:

  1. 提高了代码的重用性,子类拥有父类的方法和属性;
  2. 提高代码的可扩展性,子类可形似于父类,但异于父类,保留自我的特性;

缺点:侵入性、不够灵活、高耦合

  1. 继承是侵入的,只要继承就必须拥有父类的所有方法和属性,在一定程度上约束了子类,降低了代码的灵活性;
  2. 增加了耦合,当父类的常量、变量或者方法被修改了,需要考虑子类的修改,所以一旦父类有了变动,很可能会造成非常糟糕的结果,要重构大量的代码。 

五、接口隔离原则(‌Interface Segregation Principle, ISP)

定义:用多个专门的接口,不使用单一的总接口,客户端不应该依赖他不需要的接口

  • 一个类对应一个类的依赖应该建立在最小的接口上
  • 建立单一接口,不要建立庞大臃肿的接口
  • 尽量细化接口,接口中的方法尽量少

优点:符合高内聚低耦合的设计思想,从而使得类具有很好的可读性、可扩展性和可维护性

通俗点讲,把几个大的接口分成小接口,把接口细化。

动物接口:

public interface IAnimal {void pref();void fly();void swim();
}

狗实体:

public class Dog implements Animal {@Overridepublic void prey(){}@Overridepublic void fly(){}@Overridepublic void swim(){}
}

但是狗不会飞

鸟实体:

public class Bird implements Animal{@Overridepublic void prey(){}@Overridepublic void fly(){}@Overridepublic void swim(){}
}

鸟也不会游泳

这个时候,我们就应该把接口隔离,把它分开。

public class Bird implements IPreyable, IFlyable{@Overridepublic void prey(){}@Overridepublic void fly(){}
}

设计接口的时候呢,过大过小都不好,只有不断的思考,才能去实现

六、合成复用原则(‌Composite Reuse Principle, CRP)

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

问题由来:通常类的复用分为继承复用和合成复用两种,继承复用虽然有简单和易实现的优点,但它也存在以下缺点。

  • 继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类,父类对子类是透明的,所以这种复用又称为“白箱”复用。
  • 子类与父类的耦合度高。父类的实现的任何改变都会导致子类的实现发生变化,这不利于类的扩展与维护。
  • 它限制了复用的灵活性。从父类继承而来的实现是静态的,在编译时已经定义,所以在运行时不可能发生变化。

解决方案:合成复用原则,是通过将已有的对象纳入新对象中,作为新对象的成员对象来实现的,新对象可以调用已有对象的功能,从而达到复用的效果。

继承关系:

引擎类:

public class Engine {//发动机功率String power;//发动机排量String displacement;
}

汽车类:

public class Car extends Engine {//汽车型号String type;//汽车重量String weight;
}

使用合成类进行改造:

public class Car{//汽车型号String type;//汽车重量String weight;Engine engine;
}

使用之前的类作为现在的一个属性

合成是拥有关系,聚合是整体与部分的关系。

聚合:班级,学生,班级是一个整体,学生是一个部分,一个班级里有很多班级,这种关系叫聚合。而汽车,汽车有很多构建,他们有很多东西组成。聚合是实心的对象与实心的组合,而合成是空心与实心的实现。两者非常像。要根据具体业务进行区分。

七、迪米特法则(‌Demeter Principle, DP)

定义:一个对象对其他对象保持最少的了解。又叫最少知道原则

通俗点讲:小明、小张都想知道彼此新入职公司对方的工资,但是他们作为职业打工人心里都默念打工人基本素养(社会上的事情少打听,以免破坏员工和谐)

  • 强调只和朋友交流
  • 朋友:出现在成员变量、方法的输入、输出参数中的类成为成员朋友类,而出现在方法体内部的类不属于朋友类

优点:降低类之间的耦合

1987年美国在一个项目组提出的概念。

用例:

学生类: 

public class Student {}

班长类:

public class Monitor {public void count(List<Student> students){System.out.println("学生数:"+students.size());}
}

老师类:

public class Teacher {public void commond(Monitor monitor){List<Student> students = new ArrayList<>();for(int i=0;i<10;i++){students.add(new Student());}monitor.count(students);}
}

测试类:

public class Test {public static void main(String[] args) {Teacher teacher = new Teacher();teacher.commond(new Monitor());}
}

改造,老师只跟班长进行交流、不跟学生进行交流:

班长类:

public class Monitor {public void count(){List<Student> students = new ArrayList<>();for(int i=0;i<10;i++){students.add(new Student());}System.out.println("学生数:"+students.size());}
}

老师类:

public class Teacher {public void commond(Monitor monitor){monitor.count();}
}

单元测试类:

public class Test {public static void main(String[] args) {Teacher teacher = new Teacher();teacher.commond(new Monitor());}
}

明显职责变得更清晰了 

 

http://www.lryc.cn/news/421037.html

相关文章:

  • 利用多商家AI智能名片小程序提升消费者参与度与个性化体验:重塑零售行业的忠诚策略
  • Scala 闭包
  • 前端JS总结(中)
  • elasticsearch的match_phrase匹配及其可能导致的查询问题
  • C++快速理解之继承
  • Node.JS - 基础(Express)
  • I/O复用
  • 【验证可用】解决安装SQL Server数据库时,报错“启用 windows 功能 NetFx3 时出错,错误代码:-2146498298......“的问题
  • STM32的SDIO接口详解
  • docker容器常用指令,dockerfile
  • C语言学习笔记 Day11(指针--下)
  • (24)(24.2) Minim OSD快速安装指南(二)
  • GD32 MCU碰到IIC总线卡死怎么办?
  • 算法——动态规划:0/1 背包问题
  • 又是奇瑞,“统一下班时间”过去不久,最近又整新活了...
  • ubuntu24.04lts cmake编译 opencv4.5.4 contrib的一些问题
  • 大数据面试SQL(三):每分钟在线直播人数
  • python中执行mysql操作并将python脚本共享
  • HTTP、HTTPS、SOCKS5三种协议特点
  • 在ubuntu、centos、openEuler安装Docker
  • 公共命名空间的例子3
  • 【云存储】SDS软件定义存储,数据存储的类型与技术方案(块/文件/对象,Ceph、RBD等)
  • 第31课 Scratch入门篇:小画家(舞台上画画)
  • QT UI界面之ListView
  • freeRTOS互斥量(mutex)
  • 基于GeoTools使用JavaFx进行矢量数据可视化实战
  • zabbix的setup无法进入第二步
  • 代码随想录算法训练营第四十六天 | 115. 不同的子序列、583. 两个字符串的删除操作、72. 编辑距离、编辑距离总结篇
  • 宝塔安装nginx失败报错“检测到系统组件wget不存在,无法继续安装”
  • C++之运算符重载系列深入学习:从入门到精通!