文章目录
- 设计模式(Design Pattern,DP)
- 1、 设计模式的六大设计原则
- 2、 设计模式之创建型模式
- 3、设计模式之结构型模式
- 4、设计模式之行为型模式
- 总结
设计模式(Design Pattern,DP)
设计模式的产生背景
“设计模式”这个术语最初并不是出现在软件设计中,而是被用于建筑领域的设计中。 直到 1990 年,软件工程界才开始研讨设计模式的话题。 1995年,“四人组”(Gang of Four,GoF)合作出版了《设计模式:可复用面向对象软件的基础》(Design Patterns: Elements of Reusable Object-Oriented Software)一书,在书籍中收录了 23 个设计模式,这是设 计模式领域里程碑的事件,导致了软件设计模式的突破。 直到今天,狭义的设计模式还是该书中所介绍的23种经典设计模式。
设计模式的概念
软件设计模式(Software Design Pattern),又称设计模式,是一套被反复使用、多数人知晓的、经过分类编目的、 代码设计经验的总结。它描述了在软件设计过程中的一些不断重复发生的问题,以及该问题的解决方案。也就是说,它 是解决特定问题的一系列套路,是前辈们的代码设计经验的总结,具有一定的普遍性,可以反复使用。其目的是为了提 高代码的可重用性、代码的可读性和代码的可靠性。
1、 设计模式的六大设计原则
1.1 开闭原则:Open Closed Principle,OCP
1.1.1 开闭原则的定义
开闭原则由勃兰特·梅耶(Bertrand Meyer)提出,他在 1988 年的著作《面向对象软件构造》(Object Oriented Software Construction)中提出:软件实体应当对扩展开放,对修改关闭(Software entities should be open for extension,but closed for modification),这就是开闭原则的经典定义。简单点说就是是:一个软件实体应 该通过扩展来实现变化,而不是通过修改已有的代码来实现变化。那么什么是软件实体呢? 这里的软件实体包括以下几个部分:
- 项目中划分出的模块
- 类与接口
- 方法
一个软件产品在她的生命周期内一般都会发生变化,开闭原则视为软件实体的未来事件而制定的对现行开发设计进 行约束的一个原则。
举个例子:以书店销售书籍为例:
public interface IBook {
String getName();
int getPrice();
String getAuthor();
}
public class NovelBook implements IBook{
private String name;
private int price;
private String author;
public NovelBook(String name, int price, String author) {
this.name = name;
this.price = price;
this.author = author;
}
@Override
public String getName() {
return this.name;
}
@Override
public int getPrice() {
return this.price;
}
@Override
public String getAuthor() {
return this.author;
}
}
`public class BookStroe {
private static ArrayList<IBook> bookList=new ArrayList<>();
static {
bookList.add(new OffNovelBook("红楼梦", 9900, "曹雪芹"));
bookList.add(new OffNovelBook("侠客行", 8900, "金庸"));
bookList.add(new OffNovelBook("原则", 6900, "瑞达利欧"));
bookList.add(new OffNovelBook("海贼王1", 4900, "尾田荣一郎"));
}
public static void main(String[] args) {
System.out.println("卖书的记录如下----------------------");
for (IBook book : bookList) {
System.out.println("书籍名称:"+book.getName()+"\t\t作者:"+book.getAuthor()+"\t\t价格:¥"+book.getPrice()/100.0+"元");
}
}
}
public class OffNovelBook extends NovelBook{
public OffNovelBook(String name, int price, String author) {
super(name, price, author);
}
@Override
public int getPrice() {
int sellPrice=super.getPrice();
int offPrice=0;
if(sellPrice>7000){
offPrice=sellPrice*90/100;
}else{
offPrice=sellPrice*80/100;
}
return offPrice;
}
}
70元以上的书籍9折销售, 70元以下的书籍8折销售。对该项目来说,这就是一个变化,我们该怎么应该如下变化呢?有3中解决方法:
(1)修改接口 在IBook接口里新增getOffPrice()方法,专门用于进行打折,所有的实现类都实现该方法。但这样修改的后果就 是,实现类NovelBook要修改,书店类BookStore中的main方法也要修改,同时,IBook作为接口应该是稳定且可 靠的,不应该经常发生变化,因此,该方案被否定。
(2)修改实现类 修改NovelBook类中的方法,直接在getPrice()方法中实现打折处理,这个方法可以是可以,但如果采购书籍的人 员要看价格怎么办,由于该方法已经进行了打折处理,因此采购人员看到的也是打折后的价格,会因信息不对称出 现决策失误的情况。因此,该方案也不是一个最优的方案。
(3)通过扩展实现变化 增加一个子类OffNovelBook,覆写getPrice方法,高层次的模块(也就是BookStore中static静态块中)通过 OffNovelBook类产生新的对象,完成业务变化对系统的最小开发。这样修改也少,风险也小。
1.1.2 开闭原则的作用
开闭原则是面向对象程序设计的终极目标,它使软件实体拥有一定的适应性和灵活性的同时具备稳定性和延续性。 具体来说,其作用如下。
- 对软件测试的影响 软件遵守开闭原则的话,软件测试时只需要对扩展的代码进行测试就可以了,因为原有的测试代码仍然能够正常运 行。
- 可以提高代码的可复用性 粒度越小,被复用的可能性就越大;在面向对象的程序设计中,根据原子和抽象编程可以提高代码的可复用性。
- 可以提高软件的可维护性 遵守开闭原则的软件,其稳定性高和延续性强,从而易于扩展和维护。
1.2 单一职责原则:Single responsibility principle,SRP
这是一个备受争议的原则,跟人吵架的时候这个是屡试不爽的一个梗。 为什么会备受争议呢?怎么就能吵起来呢?主要就是对职责如何定义,什么是类的职责,以及怎么划分类的职责。 举个栗子:我们新职课的老师对学生有很多的工作要做:例如了解个人信息、每天的学习情况、记录考勤;回答学 生问题,帮助解决bug,重难点串讲;行业经验分享等。
如果将这些工作交给一位老师负责显然不合理,正确的做 法是现在我们新职课的模式:班主任负责日常工作,技术 辅导老师负责技术辅导;企业师傅负责行业经验分享等。
1.2.1 单一职责原则的定义
单一职责原则(Single Responsibility Principle,SRP)又称单一功能原则,由罗伯特·C.马丁(Robert C. Martin)于《敏捷软件开发:原则、模式和实践》一书中提出的。这里的职责是指类变化的原因,单一职责原则规 定一个类应该有且仅有一个引起它变化的原因,否则类应该被拆分(There should never be more than one reason for a class to change)。 该原则提出对象不应该承担太多职责,如果一个对象承担了太多的职责,至少存在以下两个缺点:
- 一个职责的变化可能会削弱或者抑制这个类实现其他职责的能力;
- 当客户端需要该对象的某一个职责时,不得不将其他不需要的职责全都包含进来,从而造成冗余代码或代码 的浪费。
1.2 .2 单一职责原则的优点
单一职责原则的核心就是控制类的粒度大小、将对象解耦、提高其内聚性。如果遵循单一职责原则将有以下优点。
- 降低类的复杂度。一个类只负责一项职责,其逻辑肯定要比负责多项职责简单得多。
- 提高类的可读性。复杂性降低,自然其可读性会提高。
- 提高系统的可维护性。可读性提高,那自然更容易维护了。
- 变更引起的风险降低。变更是必然的,如果单一职责原则遵守得好,当修改一个功能时,可以显著降低对其 他功能的影响。
单一职责原则是最简单但又最难运用的原则,需要设计人员发现类的不同职责并将其分离,再封装到不同的类或模 块中。而发现类的多重职责需要设计人员具有较强的分析设计能力和相关重构经验。
PS:单一职责同样也适用于方法。一个方法应该尽可能做好一件事情。如果一个方法处理的事情太多,其颗粒度会 变得很粗,不利于重用。
但是原则是死的,人是活的。所以有些时候我们可以为了效率,牺牲一定的原则性。
1.3 里氏替换原则:Liskov Substitution Principle,LSP
这是一个爱恨纠葛的父子关系的故事。该原则可以理解为:子类可以替换父类。父子类实在我们学习继承这个知识点的时候学习到的概念。我们先来回忆一下继承的优缺点:
优点:
- 代码共享,减少创建类的工作量,每个子类都拥有父类的方法和属性;
- 提高代码的重用性;
- 提高代码的可扩展性,子类可形似于父类,但异于父类,保留了自己独特的个性;其实很多开源框架的扩展都 是通过继承父类实现的。
4.提供产品或者项目的开放性。缺点:
- 继承是侵入性的,只要继承就必须拥有父类的所有方法和属性;
- 降低了代码的灵活性。子类必须拥有父类的属性和方法,让子类中多了约束
- 增加了耦合,当父类的常量、变量或者方法被修改了,需要考虑子类的修改,所以一旦父类有了变动,很可能 会造成非常糟糕的结果,要重构大量的代码。
java中使用extends关键字来实现继承,采用的是单一继承的规则,C++则采用了多重继承的规则,即一个子类可 以继承多个父类。从整体上上看,利大于弊,怎么才能更大的发挥“利”的作用呢?
解决方案就是引入里氏替换原则。什么是里氏替换原则呢?
1.3.1 里氏替换原则的定义
该原则有两个定义:
第一种:If for each object o1 of type S there is an object o2 of type T such that for all programs P defined in terms of T, the behavior of P is unchanged when o1 is substituted for o2 then S is a subtype of T.(如果每一个类型S的对象o1,都有一个类型T的对象o2,在以T定义的所有程序P中将所有的对象o2都替 换为o1,而程序P的行为没有发生变化,那么S是T的子类。)。
第二种:Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it.(所有引用基类的地方必须能透明地使用其子类对象。)
第一个定义看起来有点难,其实意思就是说:在一个程序中,如果可以将一个类T的对象全部替换为另一个类S的对 象,而程序的行为没有发生变化,那么S是T的子类。
第二个定义明显要比第一个定义更容易理解,非常的清晰明确。通俗地讲,就是任何一个使用父类的地方,你都可 以把它替换成它的子类,而不会发生任何错误或异常,使用者可能根本就不需要知道是父类还是子类。但是,反过 来就不行了,有子类出现的地方,父类未必可以替换。
里氏替换原则是继承复用的基石,它为良好的继承定义了一个规范,定义中包含了4层含义:
- 子类必须完全实现父类的方法。
- 子类中可以增加自己特有的方法。
- 当子类覆盖或实现父类的方法时,方法的输入参数(方法的形参)要比父类方法的输入参数更宽松。
- 当子类的方法实现父类的抽象方法时,方法的后置条件(即方法的返回值)要比父类更严格。
1.3.2 里氏替换原则的作用
里氏替换原则的主要作用如下。
- 里氏替换原则是实现开闭原则的重要方式之一。
- 它克服了继承中重写父类造成的可复用性变差的缺点。
- 它是动作正确性的保证。即类的扩展不会给已有的系统引入新的错误,降低了代码出错的可能性。
里氏替换原则通俗来讲就是:子类可以扩展父类的功能,但不能改变父类原有的功能。也就是说:子类继承父类 时,除添加新的方法完成新增功能外,尽量不要重写父类的方法。
如果通过重写父类的方法来完成新的功能,这样写起来虽然简单,但是整个继承体系的可复用性会比较差,特别是 运用多态比较频繁时,程序运行出错的概率会非常大。
如果程序违背了里氏替换原则,则继承类的对象在基类出现的地方会出现运行错误。这时其修正方法是:取消原来 的继承关系,重新设计它们之间的关系。
1.4 依赖倒置原则:Dependence Inversion Principle,DIP
1.4.1 依赖倒置原则的定义
依赖倒置原则的原始定义为:High level modules shouldnot depend upon low level modules.Both should depend upon abstractions.Abstractions should not depend upon details. Details should depend upon abstractions。
其实里面包含了三层含义:
- 高层模块不应该依赖低层模块,两者都应该依赖其抽象;
- 抽象不应该依赖细节。
- 细节应该依赖抽象。
核心思想:要面向接口编程,不要面向实现编程。
依赖倒置原则是实现开闭原则的重要途径之一,它降低了客户与实现模块之间的耦合。
由于在软件设计中,细节具有多变性,而抽象层则相对稳定,因此以抽象为基础搭建起来的架构要比以细节为基础 搭建起来的架构要稳定得多。这里的抽象指的是接口或者抽象类,而细节是指具体的实现类。
使用接口或者抽象类的目的是制定好规范和契约,而不去涉及任何具体的操作,把展现细节的任务交给它们的实现 类去完成。
1.4.2 依赖倒置原则的作用
- 依赖倒置原则可以降低类间的耦合性。
- 依赖倒置原则可以提高系统的稳定性。
- 依赖倒置原则可以减少并行开发引起的风险。
- 依赖倒置原则可以提高代码的可读性和可维护性。
1.4.3 依赖倒置原则的实现方法
依赖倒置原则的目的是通过要面向接口的编程来降低类间的耦合性,所以我们在实际编程中只要遵循以下4点,就 能在项目中满足这个规则。
- 每个类尽量提供接口或抽象类,或者两者都具备。
- 变量的声明类型尽量是接口或者是抽象类。
- 任何类都不应该从具体类派生。
- 尽量不要覆写基类的方法
- 使用继承时结合里氏替换原则。
1.5 接口隔离原则:Interface Segregation Principle,ISP
1.5.1 接口隔离原则的定义
接口隔离原则要求程序员尽量将臃肿庞大的接口拆分成更小的和更具体的接口,让接口中只包含客户感兴趣的方 法。2002 年罗伯特·C.马丁给“接口隔离原则”的定义是:客户端不应该被迫依赖于它不使用的方法(Clients should not be forced to depend on methods they do not use)。
该原则还有另外一个定义:一个类对另一个类的依赖应该 建立在最小的接口上(The dependency of one class to another one should depend on the smallest possible interface)。
以上两个定义的含义是:要为各个类建立它们需要的专用接口,而不要试图去建立一个很庞大的接口供所有依赖它 的类去调用。 接口隔离原则和单一职责都是为了提高类的内聚性、降低它们之间的耦合性,体现了封装的思想,但两者是不同 的:
- 单一职责原则注重的是职责,而接口隔离原则注重的是对接口依赖的隔离。
- 单一职责原则主要是约束类,它针对的是程序中的实现和细节;接口隔离原则主要约束接口,主要针对抽象 和程序整体框架的构建。
1.5.2 接口隔离原则的优点
接口隔离原则是为了约束接口、降低类对接口的依赖性,遵循接口隔离原则有以下 5 个优点。
- 将臃肿庞大的接口分解为多个粒度小的接口,可以预防外来变更的扩散,提高系统的灵活性和可维护性。
- 接口隔离提高了系统的内聚性,减少了对外交互,降低了系统的耦合性。
- 如果接口的粒度大小定义合理,能够保证系统的稳定性;但是,如果定义过小,则会造成接口数量过多,使 设计复杂化;如果定义太大,灵活性降低,无法提供定制服务,给整体项目带来无法预料的风险。
- 使用多个专门的接口还能够体现对象的层次,因为可以通过接口的继承,实现对总接口的定义。
- 能减少项目工程中的代码冗余。过大的大接口里面通常放置许多不用的方法,当实现这个接口的时候,被迫 设计冗余的代码。
1.5.3 接口隔离原则的实现方法
在具体应用接口隔离原则时,应该根据以下几个规则来衡量。
- 接口尽量小,但是要有限度。一个接口只服务于一个子模块或业务逻辑。
- 为依赖接口的类定制服务。
- 只提供调用者需要的方法,屏蔽不需要的方法。
- 了解环境,拒绝盲从。每个项目或产品都有选定的环境因素,环境不同,接口拆分的标准就不同深入了解业务逻辑。
- 提高内聚,减少对外交互。使接口用最少的方法去完成最多的事情。
1.6 迪米特法则:Law of Demeter,LoD
1.6.1迪米特法则的定义
迪米特法则(Law of Demeter,LoD)又叫作最少知识原则(Least Knowledge Principle,LKP),产生于 1987 年 美国东北大学(Northeastern University)的一个名为迪米特(Demeter)的研究项目,由伊恩·荷兰(Ian Holland)提出,它要求一个对象应该对其他对象有最少的了解。
通俗的说,一个类应该对自己需要耦合或调用的 类知道的最少,被耦合或调用的类的内部是如何复杂都与我无关,我就知道你提供的public方法就好。
迪米特法则还是在讲如何减少耦合的问题,类之间的耦合越弱,越有利于复用,一个处在弱耦合的类被修改,不会 对有关系的类造成波及。也就是说,信息的隐藏促进了软件的复用。
迪米特法则还有一个定义是:只与你的直接朋友交谈,不跟“陌生人”说话(Talk only to your immediate friends and not to strangers)。其含义是:如果两个软件实体无须直接通信,那么就不应当发生直接的相互调用,可以 通过第三方转发该调用。其目的是降低类之间的耦合度,提高模块的相对独立性。
什么叫做直接的朋友呢?每个对象都必然会和其他对象有耦合关系,两个对象之间的耦合就 成为朋友关系,这种关 系有很多比如组合、聚合、依赖等等。包括以下几类:
- 当前对象本身(this)
- 当前对象的方法参数(以参数形式传入到当前对象方法中的对象)
- 当前对象的成员对象
- 如果当前对象的成员对象是一个集合,那么集合中的元素也都是朋友
- 当前对象所创建的对象
1.6.2 迪米特法则的优点
- 降低了类之间的耦合度,提高了模块的相对独立性。
- 由于亲合度降低,从而提高了类的可复用率和系统的扩展性。
但是,过度使用迪米特法则会使系统产生大量的中介类,从而增加系统的复杂性,使模块之间的通信效率降低。所 以,在釆用迪米特法则时需要反复权衡,确保高内聚和低耦合的同时,保证系统的结构清晰。
1.6.3 迪米特法则的实现方法
从迪米特法则的定义和特点可知,它强调以下两点:
- 从依赖者的角度来说,只依赖应该依赖的对象。
- 从被依赖者的角度说,只暴露应该暴露的方法。
所以,在运用迪米特法则时要注意以下 6 点。
- 在类的划分上,应该创建弱耦合的类。类与类之间的耦合越弱,就越有利于实现可复用的目标。
- 在类的结构设计上,尽量降低类成员的访问权限。
- 在类的设计上,优先考虑将一个类设置成不变类。
- 在对其他类的引用上,将引用其他对象的次数降到最低。
- 不暴露类的属性成员,而应该提供相应的访问器(set 和 get 方法)。
- 谨慎使用序列化(Serializable)功能。
2、 设计模式之创建型模式
创建型模式的主要关注点是“怎样创建对象?”,它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的 耦合度,使用者不需要关注对象的创建细节,对象的创建由相关的工厂来完成。就像我们去商场购买商品时,不需 要知道商品是怎么生产出来一样,因为它们由专门的厂商生产。
创建型模式分为以下几种。
2.1 单例模式
2.1.1 什么是单例模式?(概念的引入)
案例:我是皇帝,独此一家。 中国自从秦始皇确立了皇帝这个职位之后,同一个时期基本上上就只有一个人孤零零的坐在皇位上啦。这种情况的 好处就是大家好办事,大家讨论或者汇报大事的时候只要提及皇帝,每个人都知道指的是谁,不需要在皇帝面前加 上特定的称呼。这种过程反应到软件设计领域就是:一个类只能产生一个对象(皇帝),大家对他的依赖都是相同 的。我们把皇帝这种特殊的职位通过程序来实现。
皇帝类:
public class Emperor {
private static Emperor emperor=null;
//构造方法私有,避免在类的外部创建对象
private Emperor() {
}
public static Emperor getInstance(){
if(emperor==null) {
emperor=new Emperor();
}
return emperor;
}
//皇帝办公
public void work(){
System.out.println("我是皇帝XXX,有事起奏,无事退朝!");
}
}
大臣类:
public class Minister {
public static void main(String[] args) {
//每天见面的都是同一个皇帝
for (int i=1;i<=5;i++){
Emperor emperor=Emperor.getInstance();
System.out.print("第"+i+"天:");
emperor.work();
}
}
}
大臣每天上朝汇报国事的对象都是同一个皇帝,这就是单例模式!
2.1.2 单例模式的定义以及特点
定义:
确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。
Ensure a class has only one instance,and provide a global point of access to it.
特点:
- 单例类只有一个实例对象;
- 该单例对象必须由单例类自行创建;
- 单例类对外提供一个访问该单例的全局访问点。
2.1.3 单例模式的分类
上面的单例模式,在低并发的情况下可能不会出现问题,如果并发量增大,内存中就会出现多个实例,就不是真正 意义上的单例。为什么会出现这种情况呢?(视频录制中语言解释) 解决线程不安全的方式有多种。我们先将上面代码的单例模式修改为线程安全的:
懒汉式单例:
public class LazyEmperor {
//保证emperor在所有线程中同步
private static volatile LazyEmperor emperor=null;
//构造方法私有,避免在类的外部创建对象
private LazyEmperor() {
}
public static synchronized LazyEmperor getInstance(){
if(emperor==null) {
emperor=new LazyEmperor();
}
return emperor;
}
//皇帝办公
public void work(){
System.out.println("我是皇帝XXX,有事起奏,无事退朝!");
}
}
该模式的特点是类加载时没有生成单例,只有当第一次调用 getlnstance 方法时才去创建这个单例。
关键字 volatile 和 synchronized,能保证线程安全,但是每次访问时都要同步,会影响性能,且消耗更多的资 源,这是懒汉式单例的缺点。
饿汉式单例:
public class HungryEmperor {
//实例化一个皇帝
private static final HungryEmperor emperor=new HungryEmperor();
//构造方法私有,避免在类的外部创建对象
private HungryEmperor(){
}
public static HungryEmperor getInstance(){
return emperor;
}
//皇帝办公
public void work