浅谈设计模式（Design Pattern）

序言：

与很多软件工程技术一样，模式起源于建筑领域，软件工程只有短短的几十年，与已经拥有几千年底蕴的建筑工程相比，后者有太多值得学习和借鉴的地方。1995年GOF（Gang Of Four四人组，Erich Gamma、Richard Helm,Ralph Johnson和John Vlissides）收集整理了23种设计模式出版了《设计模式：可复用面向对象软件的基础》一书。（GOF缺少了一个较为常用的设计模式，简单工厂方法模式，也叫静态工厂方法 Static Factory Method。对这种模式，笔者是这样理解的，简单工厂方法也是一种经常被广泛使用的设计模式，GOF提出的经典的23种设计模式中没有提及到这种设计模式。）

　“虽然设计模式描述的是面向对象编程语言，而不是过程是语言（Pascal、C、Ada）或更具动态特性的面向对象语言（CLOS、Dylan、Self）。我们从实用角度出发选择了Smalltalk和C++，因为在这些语言的使用上，我们积累了许多　况且它们也变得越来越流行”。　　　　　　　　　　　　　　　　——引言：《设计模式：可复用面向对象软件的基础》

软件设计模式本来就是一种设计上的思想，在GOF编撰的最经典的《设计模式》一书中，主要是用C++语言来描述的，书中也结合Smalltalk示例代码对设计模式进行介绍和描述。因此多数OOL(Object-Oriented Language)都可以描述和实现设计模式，关键是思想。在本篇博客当中笔者只和大家在Java语言环境下介绍和讨论Java设计模式。在下文当中，设计模式和Java设计模式是同等概念的词语。

前言：

Java设计模式是什么？在软件开发的周期里，我们(软件开发者、编程人员)为什么要使用设计模式？

设计模式的英文叫 Desing Pattern，是一套被反复使用、多数人知晓的、经过分类编辑的代码设计经验的总结。使用设计模式是为了可重用代码（可重用），让代码更容易让他人理解（易维护）并保证代码的可靠性（可靠性）。毫无疑问，设计模式于己于他人于系统都是非常实用的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目代码中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及给出了该问题的核心解决方案，这也是它能被广泛应用的原因。笔者会以理论与实践(使用代码和UML图case展示)相结合的方式来进行介绍人们广泛使用的设计模式，也希望广大编程爱好者、软件开发者，在开发编程活动中善于运用设计模式，做一个具有良好编程习惯的编程人员！

一、设计模式的分类

总体来说设计模式分为三大类，共23种设计模式：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

二、设计模式的六大原则

总原则：开闭原则（Open Close Principle）

开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，而是要扩展原有代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类等，后面的具体设计中我们会提到这点。

1、单一职责原则（Single Responsibility Principle）

不要存在多于一个导致类变更的原因，也就是说每个类应该实现单一的职责，如若不然，就应该把类拆分。

2、里氏替换原则（Liskov Substitution Principle）

里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科

历史替换原则中，子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构，通过这个规范的接口与外界交互，子类不应该随便破坏它。

3、依赖倒转原则（Dependence Inversion Principle）

这个是开闭原则的基础，具体内容：面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互。

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个的接口）要好。

5、迪米特法则（最少知道原则）（Demeter Principle）

就是说：一个类对自己依赖的类知道的越少越好。也就是说无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，通过public方法提供给外部。这样当被依赖的类变化时，才能最小的影响该类。

最少知道原则的另一个表达方式是：只与直接的朋友通信。类之间只要有耦合关系，就叫朋友关系。耦合分为依赖、关联、聚合、组合等。我们称出现为成员变量、方法参数、方法返回值中的类为直接朋友。局部变量、临时变量则不是直接的朋友。我们要求陌生的类不要作为局部变量出现在类中。

6、合成复用原则（Composite Reuse Principle）

原则是尽量首先使用合成/聚合的方式，而不是使用继承。

三、设计模式介绍

1. 创建型模式

在软件工程中，创建型模式是处理对象创建的设计模式，试图根据实际情况使用合适的方式创建对象。基本的对象创建方式可能会导致设计上的问题，或增加设计的复杂度。创建型模式通过以某种方式控制对象的创建来解决问题。创建型模式由两个主导思想构成。一是将系统使用的具体类封装起来，二是隐藏这些具体类的实例创建和结合的方式。创建型模式又分为对象创建型模式和类创建型模式。对象创建型模式处理对象的创建，类创建型模式处理类的创建。详细地说，对象创建型模式把对象创建的一部分推迟到另一个对象中，而类创建型模式将它对象的创建推迟到子类中。

1.1 抽象工厂模式(Abstract Factory)

所谓抽象工厂模式就是她提供一个接口，用于创建相关或者依赖对象的家族，而不需要明确指定具体类。他允许客户端使用抽象的接口来创建一组相关的产品，而不需要关系实际产出的具体产品是什么。这样一来，客户就可以从具体的产品中被解耦。它的优点是隔离了具体类的生成，使得客户端不需要知道什么被创建了，而缺点就在于新增新的行为会比较麻烦，因为当添加一个新的产品对象时，需要更加需要更改接口及其下所有子类。其UML结构图如下：

参与者：

AbstractFactory：抽象工厂，声明一个创建抽象产品对象的操作接口。

ConcreteFactory：具体工厂，实现创建具体对象的操作，实现AbstractProduct接口。

AbstractProduct：抽象产品，为一类产品对象声明一个接口。

ConcreteProduct：具体产品，定义一个将被相应的具体工厂创建的产品对象，实现AbstractProduct接口。

Clinent：仅使用由AbstractFactory和AbstractProduct类声明的接口。

协作过程：

通常在运行时刻创建一个ConcreteFactory类的实例。这一具体的工厂创建具有特定实现的产品对象。为创建不同的对象，客户应使用不同的具体工厂。AbstractFactory将产品对象的创建延迟到它的ConcreteFactory子类。

效果（优点）：

它（指代抽象工厂模式）分离了具体的类，抽象工厂方法模式帮助你控制一个应用创建的对象的类。因为一个工厂封装创建产品对象的责任和过程，它将客户与类的实现分离。

通俗地来讲，类的具体设计和实现细节用户不必知道也不可知道。客户通过它们的抽象接口操纵实例。产品的类名也在具体工厂的实现中被分离；它们不出现在客户代码当中。

它使得易于交换产品系列，一个具体工厂类在一个应用中仅出现一次——即它在初始化的时候。这使得改变一个应用的具体工厂变得很容易。

它只需要改变具体的工厂即可使用不同的产品配置，这是因为一个抽象工厂创建了一个完整的产品系列，所以整个产品系列会立刻改变。

它有利于产品的一致性，当一系列中的产品对象被设计成一起工作是，一个应用一次只能使用同一个系列中的对象，这一点很重要。而AbstractFactory很容易实现这一点。

缺点：

难以支持新种类的产品，难以扩展抽象工厂以生成新种类的产品。这是因为AbstractFactory接口确定了可以被创建的产品集合。

支持新种类的产品就需要扩展该抽象工厂的接口，这将涉及AbstractFactory类及其所有子类的改变。

UML类图：

示例代码：

抽象工厂对应的是产品族概念。例如，汽车产品类型可以分为轿车、SUV、MPV等，品牌也可以分为奔驰、宝马等。我们可以将奔驰的所有车型看作是一个产品族，而将宝马的所有车型看作是另一个产品族。分别对应两个工厂，一个是奔驰的工厂，另一个是宝马的工厂。与工厂方法不同，奔驰的工厂不只是生产具体的某一个产品，而是一族产品（奔驰轿车、奔驰SUV、奔驰MPV）。

听起来可能会略显复杂，我们结合上面的UML类图一起看，左上方AbstractFactory为一个工厂抽象基类，对应上例的汽车厂，当然这里的汽车厂是统称，现实中所有是不存在这样抽象的汽车厂。由AbstractFactory派生了两个工厂类Factory1和Factory2，对应上例中的奔驰、宝马汽车厂。右方的ProductA和ProductB是两个产品族，对应首轿车和SUV，当然这里也是抽象基类，是不存在的，ProductA派生了两个子类，对应了奔驰的轿车ProductA1和宝马的轿车ProductA2。所以奔驰汽车厂生产奔驰轿车、奔驰SUV，宝马汽车厂生产宝马轿车和宝马SUV。怎么生产？和工厂方法一样。

1 package com.cnblogs.lints.abstractFactoryPattern.factory;
2
3 import com.cnblogs.lints.abstractFactoryPattern.product.MPV;
4 import com.cnblogs.lints.abstractFactoryPattern.product.SUV;
5
6 public interface CarAbstractFactory {
7     SUV createSUV();
8     MPV createMPV();
9 }

CarAbstractFactory

 1 package com.cnblogs.lints.abstractFactoryPattern.factory;
 2
 3 import com.cnblogs.lints.abstractFactoryPattern.product.BMWMPV;
 4 import com.cnblogs.lints.abstractFactoryPattern.product.BMWSUV;
 5 import com.cnblogs.lints.abstractFactoryPattern.product.MPV;
 6 import com.cnblogs.lints.abstractFactoryPattern.product.SUV;
 7
 8 public class BMWFactory implements CarAbstractFactory {
 9
10     public static BMWFactory BMW_Factory = null;
11
12     private BMWFactory() {
13     }
14
15     //延迟加载的单例设计模式，确保程序中只有一个奔驰工厂对象。
16     //但下面的代码不是线程安全的,多线程下有安全隐患。
17     public static BMWFactory getBMWFactory() {
18         if(BMW_Factory == null)
19             BMW_Factory = new BMWFactory();
20         return BMW_Factory;
21     }
22
23     @Override
24     public SUV createSUV() {
25         return new BMWSUV();
26     }
27
28     @Override
29     public MPV createMPV() {
30         // TODO Auto-generated method stub
31         return new BMWMPV();
32     }
33
34 }

BMWFactory

 1 package com.cnblogs.lints.abstractFactoryPattern.factory;
 2
 3 import com.cnblogs.lints.abstractFactoryPattern.product.BenzMPV;
 4 import com.cnblogs.lints.abstractFactoryPattern.product.BenzSUV;
 5 import com.cnblogs.lints.abstractFactoryPattern.product.MPV;
 6 import com.cnblogs.lints.abstractFactoryPattern.product.SUV;
 7
 8 public class BenzFactory implements CarAbstractFactory {
 9
10     public static BenzFactory benzFactory = null;
11
12     private BenzFactory() {
13     }
14
15     //延迟加载的单例设计模式，确保程序中只有一个奔驰工厂对象。
16     //但下面的代码不是线程安全的,多线程下有安全隐患。
17     public static BenzFactory getBenzFactory() {
18         if(benzFactory == null)
19             benzFactory = new BenzFactory();
20         return benzFactory;
21     }
22
23     @Override
24     public SUV createSUV() {
25         // TODO Auto-generated method stub
26         return new BenzSUV();
27     }
28
29     @Override
30     public MPV createMPV() {
31         // TODO Auto-generated method stub
32         return new BenzMPV();
33     }
34 }

BenzFactory

1 package com.cnblogs.lints.abstractFactoryPattern.product;
2
3 public interface SUV {
4
5     void productModel();
6 }

SUV

1 package com.cnblogs.lints.abstractFactoryPattern.product;
2
3 public interface MPV {
4     void productModel();
5 }

MPV

 1 package com.cnblogs.lints.abstractFactoryPattern.product;
 2
 3 public class BenzMPV implements MPV {
 4
 5     @Override
 6     public void productModel() {
 7         System.out.println("get Benz's MPV");
 8     }
 9
10 }

BenzMPV

 1 package com.cnblogs.lints.abstractFactoryPattern.product;
 2
 3 public class BenzSUV implements SUV {
 4
 5     @Override
 6     public void productModel() {
 7         System.out.println("get Benz's SUV");
 8     }
 9
10 }

BenzSUV

 1 package com.cnblogs.lints.abstractFactoryPattern.product;
 2
 3 public class BMWMPV implements MPV{
 4
 5     @Override
 6     public void productModel() {
 7         System.out.println("get BMW's MPV");
 8     }
 9
10 }

BMWMPV

 1 package com.cnblogs.lints.abstractFactoryPattern.product;
 2
 3 public class BMWSUV implements SUV {
 4
 5     @Override
 6     public void productModel() {
 7         System.out.println("get BMW's SUV");
 8     }
 9
10 }

BMWSUV

 1 package com.cnblogs.lints.abstractFactoryPattern.client;
 2
 3 import com.cnblogs.lints.abstractFactoryPattern.factory.BMWFactory;
 4 import com.cnblogs.lints.abstractFactoryPattern.factory.BenzFactory;
 5 import com.cnblogs.lints.abstractFactoryPattern.factory.CarAbstractFactory;
 6 import com.cnblogs.lints.abstractFactoryPattern.product.MPV;
 7 import com.cnblogs.lints.abstractFactoryPattern.product.SUV;
 8
 9 public class Client {
10
11     public static void main(String[] args) {
12
13         //获得奔驰工厂对象，通过工厂对象创建奔驰汽车产品，相当于现实中人去奔驰工厂提车
14         CarAbstractFactory benzFactory = BenzFactory.getBenzFactory();
15         SUV benzSUV = benzFactory.createSUV();
16         MPV benzMPV = benzFactory.createMPV();
17
18         //展示产品
19         benzSUV.productModel();
20         benzMPV.productModel();
21
22         //获得宝马工厂对象，通过工厂对象创建宝马汽车产品，相当于现实中人去宝马工厂提车
23         CarAbstractFactory BMW_Factory = BMWFactory.getBMWFactory();
24         SUV BMW_SUV = BMW_Factory.createSUV();
25         MPV BMW_MPV = BMW_Factory.createMPV();
26
27         //展示产品
28         BMW_SUV.productModel();
29         BMW_MPV.productModel();
30     }
31
32 }

Client

1.2 工厂方法模式(Factory Method Pattern)

笔者的时间和水平有限，博客内容待补充，望读者见谅......

转载于:https://www.cnblogs.com/Lints/p/10601866.html

浅谈Java设计模式相关推荐

浅谈JAVA设计模式之——责任链模式(COR)
转载请注明出处:http://blog.csdn.net/l1028386804/article/details/45569099 一.概述使多个对象都有机会处理请求,从而避免请求的发送者和接收者之 ...
java memento_浅谈Java设计模式——备忘录模式(Memento)
一.概述在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态.这样以后就可将该对象恢复到原先保存的状态.它实现了对信息的封装,使得客户不需要关心状态保存的细节.保存就要消耗资源 ...
java mediator_浅谈Java设计模式——中介者模式(Mediator)
一.概述用一个中介对象来封装一系列的对象交互.中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互.中介对象用来封装对象之间的关系,各个对象可以不需要知道具体的信息 ...
java的byte php_java_浅谈java的byte数组的不同写法，（由于篇幅原因阐述的不够详 - phpStudy...
浅谈java的byte数组的不同写法 (由于篇幅原因阐述的不够详细科学,不喜勿喷). 经常看到java中对byte数组的不同定义,粗略整理的一下: 一个字节(byte)＝8位(bit),"b ...
JAVA如何输出六角形,浅谈 Java 六边形架构
原标题:浅谈 Java 六边形架构 dzone.com/articles/demonstration-of-hexagonal-architecture-in-java 六边形架构首先是一种设计模式, ...
浅谈Java多线程机制
浅谈Java多线程机制 (-----文中重点信息将用红色字体凸显-----) 一.话题导入在开始简述Java多线程机制之前,我不得不吐槽一下我国糟糕的IT界技术分享氛围和不给力的互联网技术解答深度. ...
java 中的单元测试_浅谈Java 中的单元测试
单元测试编写 Junit 单元测试框架对于Java语言而言,其单元测试框架,有Junit和TestNG这两种, 下面是一个典型的JUnit测试类的结构 package com.example.dem ...
浅谈 Java Printing
浅谈 Java Printing 其实怎么说呢?在写这篇博文之前,我对java printing 可以说是一无所知的.以至于我在敲文字时, 基本上是看着api文档翻译过来的.这虽然看起来非常的吃力, ...
java接口与类相同不同_浅谈java的接口和C++虚类的相同和不同之处
C++虚类相当于java中的抽象类,与接口的不同之处是: 1.一个子类只能继承一个抽象类(虚类),但能实现多个接口 2.一个抽象类可以有构造方法,接口没有构造方法 3.一个抽象类中的方法不一定是抽象方 ...

浅谈Java设计模式