栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

【设计模式】面向对象设计六大原则

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

【设计模式】面向对象设计六大原则

1 开闭原则 1.1 概念解释

开放封闭原则(简称开闭原则,Open-Close Priciple,OCP)是面向对象设计的基石,其他的原则都可以看作实现开闭原则的手段和工具

这个原则是说:软件对扩展应该是开放的,对修改应该是关闭的。意思是进行开发时,应该可以对它进行功能扩展,而在进行扩展时,不应该修改原来的程序

1.2 实现

目前对开闭原则的实现主要的就是抽象,即面向接口,把系统所有的可能行为抽象为一个底层

1.3 demo

现在有一个图像绘制类Draw,里面的方法draw()可以绘制圆形,其代码如下:

class Draw{
public:
	void drawCircle(){
		// 绘制圆形
	}
};

当新的需求修改为绘制三角形时,需要修改原来的代码,违反了开闭原则,所以可以这样修改:
把Draw修改为一个抽象类,里面的draw()为抽象方法,让子类继承并覆盖draw()即可

class Draw{
public:
	virtual void draw() = 0;
};

class CircleDrawEditer: public Draw{
public:
	void draw() override {
		// 画圆~
	}
};

class TriangleDrawEditer: public Draw{
public:
	void draw() override {
		// 画三角~
	}
};
2 单一职责原则 2.1 概念解释

单一职责模式(Single-Responsibility Principle, SRP)是指:就一个类而言,应该仅有一个引起它变化的原因,如果能想到多于一个的动机修改一个类,那么这个类就应该多于一个职责,应该把多余的职责分离出去,分别再创建类去实现

如果一个类的职责(也就是功能)过多,会出现以下问题:

  • 一个职责的变化可能会削弱或者抑制这个类实现其他职责的能力
  • 当客户端需要该对象的某一个职责时,不得不将其他不需要的职责全都包含进来,从而造成冗余代码或代码的浪费
2.2 实现

单一职责原则是最简单但又最难运用的原则,需要发现类的不同职责并将其分离,再封装到不同的类或模块中,而发现类的多重职责需要设计人员具有较强的分析设计能力和相关重构经验

在实际设计中应该考虑到明显变化的因素,没必要去寻找所有的变化,先按照当前计划完成设计,变化发生时再改变计划考虑隔离变化

2.3 demo

现在有一个Web项目,要求前后端分离:

class Project{
public:
	void doFrontEnd() {
		// 前端部分
	}
	void doBackEnd() {
		// 后端部分
	}
	void doMLAlgorithm(){
		// 机器学习算法部分
	}
};

把他们耦合起来不利于以后的维护,这时最好按照功能分开:

class FrontEndProject {
public:
	void doFrontEnd() {
		// 前端部分
	}
};
class BackEndProject {
public:
	void doBackEnd() {
		// 后端部分
	}
};
class MachineLearningProject {
public:
	void doMLAlgorithm() {
		// 机器学习算法部分
	}
};
3 里氏代换原则 3.1 概念解释

里氏代换原则(Liskov Substitution Principle, LSP)讲的是:继承必须确保超类所拥有的性质在子类中仍然成立。意思就是,两个类之间存在真正的继承关系,当且仅当其子类可以代替其超类出现的一切位置

通俗来讲就是:子类可以扩展父类的功能,但不能改变父类原有的功能

3.2 实现
  • 子类可以实现父类的抽象方法,但不能覆盖父类的非抽象方法
  • 子类中可以增加自己特有的方法
  • 当子类的方法重载父类的方法时,方法的前置条件(即方法的输入参数)要比父类的方法更宽松
  • 当子类的方法实现父类的方法时(重写/重载或实现抽象方法),方法的后置条件(即方法的的输出/返回值)要比父类的方法更严格或相等

后面这两条称为契约式设计理论(Design by Contract Theory),其中:

  • 每个方法在调用前都应判断传入参数的正确性,只有正确才能执行该方法,否则则视为违背契约,不予执行,成为前置条件(Pre-Condition)
  • 前置条件校验一旦通过,该方法必须执行,且必须保证执行结果符合契约,成为后置条件(Post-Condition)
3.3 demo

现在有一个类Brid,里面实现了fly()方法

class Brid {
public:
	void fly() {
		cout<<"fly~"< 

同时还实现了其子类Penguin,但是企鹅不会飞,所以需要覆盖其父类方法:

class Penguin: public Brid {
public:
	void fly() override {
		cout<<"I can't fly QAQ"< 

虽然设计上很符合逻辑,但是这违反了里氏代换原则,因为Penguin覆盖了父类的fly()方法,使其并不能替换所有Brid出现的地方

4 依赖倒转原则 4.1 概念解释

依赖倒转原则(Dependence Inversion Principle, DIP)是一个类与类之间的调用规则:如果一个类的一个成员或参数为一个具体类型,那么这个类就依赖于这个具体类型;如果在一个继承结构中,上层类中的一个成员或参数为一个下层类型,那么这个继承结构就是高层依赖底层,就是尽量面向接口编程

4.2 设计原则
  1. 抽象不应该依赖于具体,细节应该依赖抽象
  2. 任何类都不应该有一个指向具体类的引用
  3. 任何类都不应该从具体类派生
  4. 任何方法都不应该覆盖它的任何基类中已经实现的方法
4.3 demo

这里引用书上的一个例子:
设计一个司机类Driver和一个汽车类Car,其调用关系如下所示:

class Driver {
public:
	void drive() {
		car.start();
		while(true){
			...
		}
		car.stop();
	}
private:
	Car car = new Car();;
};

class Car {
public:
	void start() {
		// 开车~
	}
	void stop() {
		// 停车~
	}
};

似乎没什么问题,可是当司机学会开其他类型车辆(如公交车)时,需要修改源码,直接违反了开闭原则,所以这里的Driver不应该直接依赖于Car,于是引入抽象类Vehicle:

class Driver {
public: 
	void drive() {
		vehicle .start();
		while(true){
			...
		}
		vehicle .stop();
	}
private:
	auto vehicle = new Vehicle();
};

class Vehicle{
public:
	virtual void start() = 0;
	virtual void end() = 0;
};
class Car: public Vehicle {
	void start override {
		// 开小汽车~
	}
	void stop override {
		// 小汽车停了~
	}
}
class Bus: public Vehicle {
	void start override {
		// 开公交车~
	}
	void stop override {
		// 公交车停了~
	}
}
4.4 本质

依赖倒转原则的本质就是将高层对底层的依赖转变为高层与底层同时依赖于抽象

5 接口隔离原则 5.1 概念解释

接口隔离原则(Interface Segregation Principle, ISP)用于划分角色和接口,有以下两种定义:

  1. 客户端不需要依赖它不需要的接口。客户端需要什么接口,就提供给他什么样的接口,除掉客户端不需要的接口,保证接口的纯洁性
  2. 类与类之间的依赖关系应该建立在最小接口上。要求是最小接口,实际上就是要求接口的功能细化,保证接口的纯洁性

概括起来就是:建立单一接口,不要建立臃肿庞大的接口

5.2 与SRP的关系

接口隔离原则的要求实际上和单一职责原则(SRP)如出一辙,其实是有差别的

  • SRP定义中的单一职责是指类的功能单一。有一个类,实现一个需求功能可能需要10个方法辅助完成,这10个方法就不会违背SRP
  • 而ISP定义中的隔离是指:接口的功能趋向专门化,一个接口的设计不能过于臃肿,这就要求在完成一个功能时设计出很多专门化、细化的接口

对于上述的例子来说,虽然没有违反SRP,但是违反了ISP,因为这个类的方法过于臃肿了,需要细化

5.3 demo

对于一个学生成绩管理系统来说,其功能主要包括成绩的增删改查、分数计算、打印成绩,对这个类的定义可以像这样:

class StudentInfoSystem {
public:
	void insertGradeInfo(Student student) {
		...
	}
	void deleteGradeInfo()(Student student) {
		...
	}
	void modifyGradeInfo()(Student student) {
		...
	}
	Info* queryGradeInfo()(Student student) {
		...
	}
	Student gradeCalculate()(Student student) {
		...
	}
	void gradeDisplay()(Student student) {
		...
	}
};

这些功能中,有的是在输入阶段,有的是在输出阶段,还有的是在分数统计阶段,这样明显不太合理,应该将其拆分为上述3个模块,在对应模块中实现对应的方法:

class StudentInfoSystem {
public:
	void run() {
		auto* inputModule = new InputModule ();
		auto* displayModule = new DisplayModule ();
		auto* calculateModule = new CalculateModule ();
		inputModule.insertGradeInfo({"UltraMar1ne", "Design Pattern", 99});
		...
	}
private:
	auto* inputModule;
	auto* displayModule;
	auto* calculateModule;
};

class InputModule {
public:
	void insertGradeInfo(Student student) {
		...
	}
	void deleteGradeInfo()(Student student) {
		...
	}
	void modifyGradeInfo()(Student student) {
		...
	}
};

class DisplayModule {
public:
	Info* queryGradeInfo()(Student student) {
		...
	}
	void gradeDisplay()(Student student) {
		...
	}
};
class CalculateModule {
public:
	Student gradeCalculate()(Student student) {
		...
	}
}
6 迪米特法则 6.1 概念解释

迪米特法则(Law of Demeter, LoD),也成为最少知识原则(Least Knowledeg Principle, LKP),其含义为:一个对象应该对其他对象有最小的了解。换句话说就是:一个类不管内部多复杂、多耦合,和调用这个类的其他类没有关系,这个类暴露出来多少个public方法,别的类就调用那些public方法

6.2 其他解释
  • 一个软件实体应当尽可能少的与其他实体发生相互作用
  • 每一个软件单位对其他单位都只有最少的认识,而且局限于那些与本单位密切相关的软件单位
  • 由于每个类尽量减少对其他类的依赖关系,因此很容易实现模块功能独立化,相互之间很少或没有依赖关系
  • 迪米特法则不希望类之间建立直接的联系,如果真的有需要,可以通过友元类转达,但这也在一定程度上增加了系统的复杂度
6.3 demo

现要实现一个租房系统,有房源与租房者两个类:

class House {
	...
};

class Tenant {
	...
};

如果让租客直接去访问住房信息,看似符合逻辑,但是却违背了迪米特法则,这时可以设计一个新类Agency,让它作为Tenant与House通信的桥梁:

class Agency {
public:
	void seeHouse(){

	}
	void rentHouse(){
	
	}
	...
private:
	Tenant* tenant;
	House* house;
};
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/946142.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号