创建型模式
创建型模式的特点和分类
创建型模式的主要关注点是“怎样创建对象？”，它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度，使用者不需要关注对象的创建细节，对象的创建由相关的工厂来完成。就像我们去商场购买商品时，不需要知道商品是怎么生产出来一样，因为它们由专门的厂商生产。
创建型模式分为以下几种。
- 单例（Singleton）模式：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。
- 原型（Prototype）模式：将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例。
- 工厂方法（FactoryMethod）模式：定义一个用于创建产品的接口，由子类决定生产什么产品。
- 抽象工厂（AbstractFactory）模式：提供一个创建产品族的接口，其每个子类可以生产一系列相关的产品。
- 建造者（Builder）模式：将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。
以上 5 种创建型模式，除了工厂方法模式属于类创建型模式，其他的全部属于对象创建型模式，我们将在之后的教程中详细地介绍它们的特点、结构与应用。单例模式
在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。单例模式的定义与特点
单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。
在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、数据库的连接池、网站的计数器、Web 应用的配置对象、应用程序中的对话框、系统中的缓存等常常被设计成单例。
单例模式在现实生活中的应用也非常广泛，例如公司 CEO、部门经理等都属于单例模型。J2EE 标准中的 ServletContext 和 ServletContextConfig、Spring 框架应用中的 ApplicationContext、数据库中的连接池等也都是单例模式。
单例模式有 3 个特点：
- 单例模式可以保证内存里只有一个实例，减少了内存的开销。
- 可以避免对资源的多重占用。
- 单例模式设置全局访问点，可以优化和共享资源的访问。
单例模式的缺点： - 单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。
- 在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。
- 单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。
单例模式看起来非常简单，实现起来也非常简单。单例模式在面试中是一个高频面试题。希望大家能够认真学习，掌握单例模式，提升核心竞争力，给面试加分，顺利拿到 Offer。
单例模式的应用场景
对于 Java 来说，单例模式可以保证在一个 JVM 中只存在单一实例。单例模式的应用场景主要有以下几个方面。
- 需要频繁创建的一些类，使用单例可以降低系统的内存压力，减少 GC。
- 某类只要求生成一个对象的时候，如一个班中的班长、每个人的身份证号等。
- 某些类创建实例时占用资源较多，或实例化耗时较长，且经常使用。
- 某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。
- 频繁访问数据库或文件的对象。
- 对于一些控制硬件级别的操作，或者从系统上来讲应当是单一控制逻辑的操作，如果有多个实例，则系统会完全乱套。
当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。
单例模式的结构与实现
单例模式是设计模式中最简单的模式之一。通常，普通类的构造函数是公有的，外部类可以通过“new 构造函数()”来生成多个实例。但是，如果将类的构造函数设为私有的，外部类就无法调用该构造函数，也就无法生成多个实例。这时该类自身必须定义一个静态私有实例，并向外提供一个静态的公有函数用于创建或获取该静态私有实例。
下面来分析其基本结构和实现方法。1. 单例模式的结构
单例模式的主要角色如下。
单例类：包含一个实例且能自行创建这个实例的类。
- 访问类：使用单例的类。
其结构如图 1 所示。
2. 单例模式的实现
可以参考设计模式(下)：https://www.yuque.com/doaprettyboy/qekfko/bsn26g
Singleton 模式通常有两种实现形式。
第 1 种：饿汉式单例
该模式的特点是类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了。
// 为什么要加final？？因为防止子类破坏单例public final class HungrySingleton {// final必须加吗？ 我想不是的，因为外部本来就无法访问private static final HungrySingleton instance = new HungrySingleton();private HungrySingleton() {}public static HungrySingleton getInstance() {return instance;}}
饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的（重要的是：由JVM创建），可以直接用于多线程而不会出现问题。
第2种：懒汉式单例
该模式的特点是类加载时没有生成单例，只有当第一次调用 getlnstance 方法时才去创建这个单例。代码如下：
public class LazySingleton {private LazySingleton(){//private 避免类在外部被实例化}private static LazySingleton instance = null;public static synchronized LazySingleton getInstance() {if (instance == null) {instance = new LazySingleton();}return instance}}
注意：如果编写的是多线程程序，则不要删除上例代码中的关键字 volatile 和 synchronized（vloatile不需要加），否则将存在线程非安全的问题。如果不删除这两个关键字就能保证线程安全，但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。
这个缺点很明显，锁的消耗太大，每次都要加锁！
第3种：Double Check
public final class Singleton {private Singleton() { }// 问题1：解释为什么要加 volatile ?private static volatile Singleton INSTANCE = null;// 问题2：对比实现3, 说出这样做的意义public static Singleton getInstance() {if (INSTANCE != null) {return INSTANCE;}synchronized (Singleton.class) {// 问题3：为什么还要在这里加为空判断, 之前不是判断过了吗 防止首次创建，多个线程的并发问题if (INSTANCE != null) { // t2return INSTANCE;}INSTANCE = new Singleton();return INSTANCE;}}}
或
public final class Singleton {private Singleton() { }private static Singleton INSTANCE = null;public static Singleton getInstance() {if(INSTANCE == null) { // t2// 首次访问会同步，而之后的使用没有 synchronizedsynchronized(Singleton.class) {if (INSTANCE == null) { // t1INSTANCE = new Singleton();}}}return INSTANCE;}}
第4种：枚举类
https://blog.csdn.net/ly199108171231/article/details/85242873
// 问题1：枚举单例是如何限制实例个数的 里面定义几个，就有几个实例// 问题2：枚举单例在创建时是否有并发问题 没有，因为其也是静成员变量，也是在类加载阶段完成的// 问题3：枚举单例能否被反射破坏单例 不能// 问题4：枚举单例能否被反序列化破坏单例 强调一下，枚举类都是默认实现序列化接口的，但是枚举类设计考虑到了这个破坏单例，因此不可以破话// 问题5：枚举单例属于懒汉式还是饿汉式 饿汉式// 问题6：枚举单例如果希望加入一些单例创建时的初始化逻辑该如何做 很简单，加入构造方法就可以了，枚举类也可以加构造方法enum Singleton {INSTANCE;}
灵魂拷问：
- 如何限制个数？？
- 是否有并发，无，因为JVM实现
- 序列化是否破坏单例？ 枚举类设计时就实现了序列化接口，但是考虑到了，设计成不会破坏
- 反射呢？ 不能，会抛出异常！
-
第5种：静态内部类
public final class Singleton {private Singleton() { }// 问题1：属于懒汉式还是饿汉式 懒汉式private static class LazyHolder {static final Singleton INSTANCE = new Singleton();}// 问题2：在创建时是否有并发问题 没有，因为是JVM操作public static Singleton getInstance() {return LazyHolder.INSTANCE;}}
单例模式的应用实例
【例1】用懒汉式单例模式模拟产生美国当今总统对象。
分析：在每一届任期内，美国的总统只有一人，所以本实例适合用单例模式实现，图 2 所示是用懒汉式单例实现的结构图。
```java
public class SingletonLazy {
public static void main(String[] args) {President zt1 = President.getInstance();zt1.getName(); //输出总统的名字President zt2 = President.getInstance();zt2.getName(); //输出总统的名字if (zt1 == zt2) {System.out.println("他们是同一人！");} else {System.out.println("他们不是同一人！");}
} }
class President { private static volatile President instance = null; //保证instance在所有线程中同步
//private避免类在外部被实例化private President() {System.out.println("产生一个总统！");}public static synchronized President getInstance() {//在getInstance方法上加同步if (instance == null) {instance = new President();} else {System.out.println("已经有一个总统，不能产生新总统！");}return instance;}public void getName() {System.out.println("我是美国总统：特朗普。");}
}
程序运行结果如下：```java产生一个总统！我是美国总统：特朗普。已经有一个总统，不能产生新总统！我是美国总统：特朗普。他们是同一人！
单例模式的扩展
单例模式可扩展为有限的多例（Multitcm）模式，这种模式可生成有限个实例并保存在 ArrayList 中，客户需要时可随机获取，其结构图如图 5 所示。
进阶阅读
如果您想了解单例模式在框架源码中的应用，可猛击阅读《单例模式在JDK和Spring源码中的应用》文章。
原型模式
感觉这个博客写的不错！https://blog.csdn.net/qq_40709468/article/details/82316418
在有些系统中，存在大量相同或相似对象的创建问题，如果用传统的构造函数来创建对象，会比较复杂且耗时耗资源，用原型模式生成对象就很高效，就像孙悟空拔下猴毛轻轻一吹就变出很多孙悟空一样简单。
原型模式的定义与特点
原型（Prototype）模式的定义如下：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。例如，Windows 操作系统的安装通常较耗时，如果复制就快了很多。在生活中复制的例子非常多，这里不一一列举了。
原型模式的优缺点
原型模式的优点：
- Java 自带的原型模式基于内存二进制流的复制，在性能上比直接 new 一个对象更加优良。
- 可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份，并将其状态保存起来，简化了创建对象的过程，以便在需要的时候使用（例如恢复到历史某一状态），可辅助实现撤销操作。
原型模式的缺点：
- 需要为每一个类都配置一个 clone 方法
- clone 方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违背了开闭原则。
- 当实现深克隆时，需要编写较为复杂的代码，而且当对象之间存在多重嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来会比较麻烦。因此，深克隆、浅克隆需要运用得当。
原型模式的结构与实现
由于 Java 提供了对象的 clone() 方法，所以用 Java 实现原型模式很简单。1. 模式的结构
原型模式包含以下主要角色。
- 抽象原型类：规定了具体原型对象必须实现的接口。
- 具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
- 访问类：使用具体原型类中的 clone() 方法来复制新的对象。
其结构图如图 1 所示。
2. 模式的实现
原型模式的克隆分为浅克隆和深克隆。
- 浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。
深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。
Java 中的 Object 类提供了浅克隆的 clone() 方法，具体原型类只要实现 Cloneable 接口就可实现对象的浅克隆，这里的 Cloneable 接口就是抽象原型类。其代码如下： ```java //具体原型类 class Realizetype implements Cloneable { Realizetype() {System.out.println("具体原型创建成功！");
}
public Object clone() throws CloneNotSupportedException {
System.out.println("具体原型复制成功！");return (Realizetype) super.clone();
} }
//原型模式的测试类 public class PrototypeTest { public static void main(String[] args) throws CloneNotSupportedException { Realizetype obj1 = new Realizetype(); Realizetype obj2 = (Realizetype) obj1.clone(); System.out.println(“obj1==obj2?” + (obj1 == obj2)); } }
程序的运行结果如下：```java具体原型创建成功！具体原型复制成功！obj1==obj2?false
原型模式的应用实例
【例1】用原型模式模拟“孙悟空”复制自己。
分析：孙悟空拔下猴毛轻轻一吹就变出很多孙悟空，这实际上是用到了原型模式。这里的孙悟空类 SunWukong 是具体原型类，而 Java 中的 Cloneable 接口是抽象原型类。
很简单，代码略！
【例2】用原型模式生成“三好学生”奖状。
分析：同一学校的“三好学生”奖状除了获奖人姓名不同，其他都相同，属于相似对象的复制，同样可以用原型模式创建，然后再做简单修改就可以了。图 4 所示是三好学生奖状生成器的结构图。
public class ProtoTypeCitation {public static void main(String[] args) throws CloneNotSupportedException {citation obj1 = new citation("张三", "同学：在2016学年第一学期中表现优秀，被评为三好学生。", "韶关学院");obj1.display();citation obj2 = (citation) obj1.clone();obj2.setName("李四");obj2.display();}}//奖状类class citation implements Cloneable {String name;String info;String college;citation(String name, String info, String college) {this.name = name;this.info = info;this.college = college;System.out.println("奖状创建成功！");}void setName(String name) {this.name = name;}String getName() {return (this.name);}void display() {System.out.println(name + info + college);}public Object clone() throws CloneNotSupportedException {System.out.println("奖状拷贝成功！");return (citation) super.clone();}}
程序运行结果如下：
奖状创建成功！张三同学：在2016学年第一学期中表现优秀，被评为三好学生。韶关学院奖状拷贝成功！李四同学：在2016学年第一学期中表现优秀，被评为三好学生。韶关学院
原型模式的应用场景
原型模式通常适用于以下场景。
- 对象之间相同或相似，即只是个别的几个属性不同的时候。
- 创建对象成本较大，例如初始化时间长，占用CPU太多，或者占用网络资源太多等，需要优化资源。
- 创建一个对象需要繁琐的数据准备或访问权限等，需要提高性能或者提高安全性。
- 系统中大量使用该类对象，且各个调用者都需要给它的属性重新赋值。
在 Spring 中，原型模式应用的非常广泛，例如 scope=’prototype’、JSON.parseObject() 等都是原型模式的具体应用。原型模式的扩展
原型模式可扩展为带原型管理器的原型模式，它在原型模式的基础上增加了一个原型管理器 PrototypeManager 类。该类用 HashMap 保存多个复制的原型，Client 类可以通过管理器的 get(String id) 方法从中获取复制的原型。其结构图如图 5 所示。
【例3】用带原型管理器的原型模式来生成包含“圆”和“正方形”等图形的原型，并计算其面积。分析：本实例中由于存在不同的图形类，例如，“圆”和“正方形”，它们计算面积的方法不一样，所以需要用一个原型管理器来管理它们，图 6 所示是其结构图。
程序代码如下： ```java import java.util.*;
interface Shape extends Cloneable { public Object clone(); //拷贝
public void countArea(); //计算面积
}
class Circle implements Shape { public Object clone() { Circle w = null; try { w = (Circle) super.clone(); } catch (CloneNotSupportedException e) { System.out.println(“拷贝圆失败!”); } return w; }
public void countArea() {int r = 0;System.out.print("这是一个圆，请输入圆的半径：");Scanner input = new Scanner(System.in);r = input.nextInt();System.out.println("该圆的面积=" + 3.1415 * r * r + "\n");}
}
class Square implements Shape { public Object clone() { Square b = null; try { b = (Square) super.clone(); } catch (CloneNotSupportedException e) { System.out.println(“拷贝正方形失败!”); } return b; }
public void countArea() {int a = 0;System.out.print("这是一个正方形，请输入它的边长：");Scanner input = new Scanner(System.in);a = input.nextInt();System.out.println("该正方形的面积=" + a * a + "\n");}
}
class ProtoTypeManager {
private HashMap
public ProtoTypeManager() {ht.put("Circle", new Circle());ht.put("Square", new Square());}public void addshape(String key, Shape obj) {ht.put(key, obj);}public Shape getShape(String key) {Shape temp = ht.get(key);return (Shape) temp.clone();}
}
public class ProtoTypeShape { public static void main(String[] args) { ProtoTypeManager pm = new ProtoTypeManager(); Shape obj1 = (Circle) pm.getShape(“Circle”); obj1.countArea(); Shape obj2 = (Shape) pm.getShape(“Square”); obj2.countArea(); } }
运行结果如下所示：<a name="umhtJ"></a>### 进阶阅读原型模式也称为克隆模式，如果您想深入了解原型（克隆）模式，可以猛击阅读下面的文章。- [《浅克隆和深克隆》](http://c.biancheng.net/view/vip_8379.html)- [《克隆会破坏单例对象吗》](http://c.biancheng.net/view/vip_8382.html)- [《原型模式在JDK源码中的应用》](http://c.biancheng.net/view/vip_8383.html)<a name="Qmh5d"></a>## 简单工厂模式可以参考这篇：[https://www.cnblogs.com/oukele/p/10087662.html](https://www.cnblogs.com/oukele/p/10087662.html)<br />现实生活中，原始社会自给自足（没有工厂），农耕社会小作坊（简单工厂，民间酒坊），工业革命流水线（工厂方法，自产自销），现代产业链代工厂（抽象工厂，富士康）。我们的项目代码同样是由简到繁一步一步迭代而来的，但对于调用者来说，却越来越简单。<br /> 在日常开发中，**凡是需要生成复杂对象的地方，都可以尝试考虑使用工厂模式来代替**。> **注意：上述复杂对象指的是类的构造函数参数过多等对类的构造有影响的情况，因为类的构造过于复杂，如果直接在其他业务类内使用，则两者的耦合过重，后续业务更改，就需要在任何引用该类的源代码内进行更改，光是查找所有依赖就很消耗时间了，更别说要一个一个修改了。**工厂模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。<br /> 按实际业务场景划分，工厂模式有 3 种不同的实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式。<br /> 我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。**如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”**。<br /> 在简单工厂模式中创建实例的方法通常为静态（static）方法，因此简单工厂模式（Simple Factory Pattern）又叫作静态工厂方法模式（Static Factory Method Pattern）。<br /> 简单来说，简单工厂模式有一个具体的工厂类，可以生成多个不同的产品，属于创建型设计模式。简单工厂模式不在 GoF 23 种设计模式之列。<br /> 简单工厂模式每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度，违背了“开闭原则”。<br />“工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。<a name="GjDXj"></a>### 优点和缺点<a name="BoZA7"></a>#### 优点：1. 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。1. 客户端无需知道所创建具体产品的类名，只需知道参数即可。1. 也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。<a name="aXcwd"></a>#### 缺点：1. 简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，一旦异常，整个系统将受影响。且工厂类代码会非常臃肿，违背高聚合原则。1. 使用简单工厂模式会增加系统中类的个数（引入新的工厂类），增加系统的复杂度和理解难度1. 系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂1. 简单工厂模式使用了 static 工厂方法，造成工厂角色无法形成基于继承的等级结构。<a name="wdFyR"></a>### 应用场景对于产品种类相对较少的情况，考虑使用简单工厂模式。使用简单工厂模式的客户端只需要传入工厂类的参数，不需要关心如何创建对象的逻辑，可以很方便地创建所需产品。<a name="YFKbV"></a>### 模式的结构与实现简单工厂模式的主要角色如下：- 简单工厂（SimpleFactory）：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。- 抽象产品（Product）：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。- 具体产品（ConcreteProduct）：是简单工厂模式的创建目标。<br />其结构图如下图所示。<br />根据上图写出该模式的代码如下：```javapublic class Client {public static void main(String[] args) {}//抽象产品public interface Product {void show();}//具体产品：ProductAstatic class ConcreteProduct1 implements Product {public void show() {System.out.println("具体产品1显示...");}}//具体产品：ProductBstatic class ConcreteProduct2 implements Product {public void show() {System.out.println("具体产品2显示...");}}final class Const {static final int PRODUCT_A = 0;static final int PRODUCT_B = 1;static final int PRODUCT_C = 2;}static class SimpleFactory {public static Product makeProduct(int kind) {switch (kind) {case Const.PRODUCT_A:return new ConcreteProduct1();case Const.PRODUCT_B:return new ConcreteProduct2();}return null;}}}
进阶阅读
如果您想了解简单工厂模式在框架源码中的应用，可猛击阅读《简单工厂模式在框架源码中的应用》文章。
工厂方法模式(工厂模式) 详解版
在现实生活中社会分工越来越细，越来越专业化。各种产品有专门的工厂生产，彻底告别了自给自足的小农经济时代，这大大缩短了产品的生产周期，提高了生产效率。同样，在软件开发中能否做到软件对象的生产和使用相分离呢？能否在满足“开闭原则”的前提下，客户随意增删或改变对软件相关对象的使用呢？这就是本节要讨论的问题。
在《简单工厂模式》一节我们介绍了简单工厂模式，提到了简单工厂模式违背了开闭原则，而“工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。
工厂方法优缺点
优点：
- 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
- 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。
缺点：
类的个数容易过多，增加复杂度
- 增加了系统的抽象性和理解难度
-
应用场景：
客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。
- 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
- 客户不关心创建产品的细节，只关心产品的品牌
模式的结构与实现
工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品等4个要素构成。本节来分析其基本结构和实现方法。1. 模式的结构
工厂方法模式的主要角色如下。
- 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
- 具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
- 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
- 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。
其结构图如图 1 所示。
2. 模式的实现
根据图 1 写出该模式的代码如下：
package FactoryMethod;public class AbstractFactoryTest {public static void main(String[] args) {try {Product a;AbstractFactory af;af = (AbstractFactory) ReadXML1.getObject();a = af.newProduct();a.show();} catch (Exception e) {System.out.println(e.getMessage());}}}//抽象产品：提供了产品的接口interface Product {public void show();}//具体产品1：实现抽象产品中的抽象方法class ConcreteProduct1 implements Product {public void show() {System.out.println("具体产品1显示...");}}//具体产品2：实现抽象产品中的抽象方法class ConcreteProduct2 implements Product {public void show() {System.out.println("具体产品2显示...");}}//抽象工厂：提供了厂品的生成方法（生成产品）interface AbstractFactory {public Product newProduct();}//具体工厂1：实现了厂品的生成方法class ConcreteFactory1 implements AbstractFactory {public Product newProduct() {System.out.println("具体工厂1生成-->具体产品1...");return new ConcreteProduct1();}}//具体工厂2：实现了厂品的生成方法class ConcreteFactory2 implements AbstractFactory {public Product newProduct() {System.out.println("具体工厂2生成-->具体产品2...");return new ConcreteProduct2();}}
package FactoryMethod;import javax.xml.parsers.*;import org.w3c.dom.*;import java.io.*;class ReadXML1 {//该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象public static Object getObject() {try {//创建文档对象DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();DocumentBuilder builder = dFactory.newDocumentBuilder();Document doc;doc = builder.parse(new File("src/FactoryMethod/config1.xml"));//获取包含类名的文本节点NodeList nl = doc.getElementsByTagName("className");Node classNode = nl.item(0).getFirstChild();String cName = "FactoryMethod." + classNode.getNodeValue();//System.out.println("新类名："+cName);//通过类名生成实例对象并将其返回Class<?> c = Class.forName(cName);Object obj = c.newInstance();return obj;} catch (Exception e) {e.printStackTrace();return null;}}}
xml文件
<?xml version="1.0" encoding="UTF-8"?><config><className>ConcreteFactory1</className></config>
程序运行结果如下：
具体工厂1生成-->具体产品1...具体产品1显示...
如果将 XML 配置文件中的 ConcreteFactory1 改为 ConcreteFactory2，则程序运行结果如下：
具体工厂2生成-->具体产品2...具体产品2显示...
模式的应用实例
【例1】用工厂方法模式设计畜牧场。
分析：有很多种类的畜牧场，如养马场用于养马，养牛场用于养牛，所以该实例用工厂方法模式比较适合。
对养马场和养牛场等具体工厂类，只要定义一个生成动物的方法 newAnimal() 即可。由于要显示马类和牛类等具体产品类的图像，所以它们的构造函数中用到了 JPanel、JLabd 和 ImageIcon 等组件，并定义一个 show() 方法来显示它们。
客户端程序通过对象生成器类 ReadXML2 读取 XML 配置文件中的数据来决定养马还是养牛。其结构图如图 2 所示。
注意：该程序中用到了 XML 文件，并且要显示马类和牛类等具体产品类的图像，如果想要获取 HTML 文件和图片，请点击“下载”，就可以对其进行下载。
程序代码如下：
程序代码如下：
package FactoryMethod;import java.awt.*;import javax.swing.*;public class AnimalFarmTest {public static void main(String[] args) {try {Animal a;AnimalFarm af;af = (AnimalFarm) ReadXML2.getObject();a = af.newAnimal();a.show();} catch (Exception e) {System.out.println(e.getMessage());}}}//抽象产品：动物类interface Animal {public void show();}//具体产品：马类class Horse implements Animal {JScrollPane sp;JFrame jf = new JFrame("工厂方法模式测试");public Horse() {Container contentPane = jf.getContentPane();JPanel p1 = new JPanel();p1.setLayout(new GridLayout(1, 1));p1.setBorder(BorderFactory.createTitledBorder("动物：马"));sp = new JScrollPane(p1);contentPane.add(sp, BorderLayout.CENTER);JLabel l1 = new JLabel(new ImageIcon("src/A_Horse.jpg"));p1.add(l1);jf.pack();jf.setVisible(false);jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //用户点击窗口关闭}public void show() {jf.setVisible(true);}}//具体产品：牛类class Cattle implements Animal {JScrollPane sp;JFrame jf = new JFrame("工厂方法模式测试");public Cattle() {Container contentPane = jf.getContentPane();JPanel p1 = new JPanel();p1.setLayout(new GridLayout(1, 1));p1.setBorder(BorderFactory.createTitledBorder("动物：牛"));sp = new JScrollPane(p1);contentPane.add(sp, BorderLayout.CENTER);JLabel l1 = new JLabel(new ImageIcon("src/A_Cattle.jpg"));p1.add(l1);jf.pack();jf.setVisible(false);jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //用户点击窗口关闭}public void show() {jf.setVisible(true);}}//抽象工厂：畜牧场interface AnimalFarm {public Animal newAnimal();}//具体工厂：养马场class HorseFarm implements AnimalFarm {public Animal newAnimal() {System.out.println("新马出生！");return new Horse();}}//具体工厂：养牛场class CattleFarm implements AnimalFarm {public Animal newAnimal() {System.out.println("新牛出生！");return new Cattle();}}
package FactoryMethod;import javax.xml.parsers.*;import org.w3c.dom.*;import java.io.*;class ReadXML2 {public static Object getObject() {try {DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();DocumentBuilder builder = dFactory.newDocumentBuilder();Document doc;doc = builder.parse(new File("src/FactoryMethod/config2.xml"));NodeList nl = doc.getElementsByTagName("className");Node classNode = nl.item(0).getFirstChild();String cName = "FactoryMethod." + classNode.getNodeValue();System.out.println("新类名：" + cName);Class<?> c = Class.forName(cName);Object obj = c.newInstance();return obj;} catch (Exception e) {e.printStackTrace();return null;}}}
程序的运行结果如图 3 所示。
注意：当需要生成的产品不多且不会增加，一个具体工厂类就可以完成任务时，可删除抽象工厂类。这时工厂方法模式将退化到简单工厂模式。
进阶阅读
如果您想了解工厂方法模式在框架源码中的应用，可猛击阅读《工厂方法模式在Logback源码中的应用》文章。
抽象工厂模式（详解版）
建造者模式(Builder模式)详解
可参考博客：https://www.jianshu.com/p/47329a94f5dc
在软件开发过程中有时需要创建一个复杂的对象，这个复杂对象通常由多个子部件按一定的步骤组合而成。例如，计算机是由 CPU、主板、内存、硬盘、显卡、机箱、显示器、键盘、鼠标等部件组装而成的，采购员不可能自己去组装计算机，而是将计算机的配置要求告诉计算机销售公司，计算机销售公司安排技术人员去组装计算机，然后再交给要买计算机的采购员。
生活中这样的例子很多，如游戏中的不同角色，其性别、个性、能力、脸型、体型、服装、发型等特性都有所差异；还有汽车中的方向盘、发动机、车架、轮胎等部件也多种多样；每封电子邮件的发件人、收件人、主题、内容、附件等内容也各不相同。
以上所有这些产品都是由多个部件构成的，各个部件可以灵活选择，但其创建步骤都大同小异。这类产品的创建无法用前面介绍的工厂模式描述，只有建造者模式可以很好地描述该类产品的创建。
模式的定义与特点
建造者（Builder）模式的定义：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。
模式的优缺点
该模式的主要优点如下：
- 封装性好，构建和表示分离。
- 扩展性好，各个具体的建造者相互独立，有利于系统的解耦。
- 客户端不必知道产品内部组成的细节，建造者可以对创建过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险。
其缺点如下：
- 产品的组成部分必须相同，这限制了其使用范围。
- 如果产品的内部变化复杂，如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大。
建造者（Builder）模式和工厂模式的关注点不同：建造者模式注重零部件的组装过程，而工厂方法模式更注重零部件的创建过程，但两者可以结合使用。
模式的结构与实现
建造者（Builder）模式由产品、抽象建造者、具体建造者、指挥者等 4 个要素构成，现在我们来分析其基本结构和实现方法。
1. 模式的结构
建造者（Builder）模式的主要角色如下。
- 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。
- 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
- 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
- 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。
2. 模式的实现
图 1 给出了建造者（Builder）模式的主要结构，其相关类的代码如下。
(1) 产品角色：包含多个组成部件的复杂对象。
class Product {private String partA;private String partB;private String partC;public void setPartA(String partA) {this.partA = partA;}public void setPartB(String partB) {this.partB = partB;}public void setPartC(String partC) {this.partC = partC;}public void show() {//显示产品的特性}}
(2) 抽象建造者：包含创建产品各个子部件的抽象方法。（某个部分也可以是固定的）
abstract class Builder {//创建产品对象protected Product product = new Product();public abstract void buildPartA();public abstract void buildPartB();public abstract void buildPartC();//返回产品对象public Product getResult() {return product;}}
(3) 具体建造者：实现了抽象建造者接口。
public class ConcreteBuilder extends Builder {public void buildPartA() {product.setPartA("建造 PartA");}public void buildPartB() {product.setPartB("建造 PartB");}public void buildPartC() {product.setPartC("建造 PartC");}}
(4) 指挥者：调用建造者中的方法完成复杂对象的创建。
class Director {private Builder builder;public Director(Builder builder) {this.builder = builder;}//产品构建与组装方法public Product construct() {builder.buildPartA();builder.buildPartB();builder.buildPartC();return builder.getResult();}}
(5) 客户类。
public class Client {public static void main(String[] args) {Builder builder = new ConcreteBuilder();Director director = new Director(builder);Product product = director.construct();product.show();}}
模式的应用实例
【例1】用建造者（Builder）模式描述客厅装修。
分析：客厅装修是一个复杂的过程，它包含墙体的装修、电视机的选择、沙发的购买与布局等。客户把装修要求告诉项目经理，项目经理指挥装修工人一步步装修，最后完成整个客厅的装修与布局，所以本实例用建造者模式实现比较适合。
这里客厅是产品，包括墙、电视和沙发等组成部分。具体装修工人是具体建造者，他们负责装修与墙、电视和沙发的布局。项目经理是指挥者，他负责指挥装修工人进行装修。
另外，客厅类中提供了 show() 方法，可以将装修效果图显示出来（点此下载装修效果图的图片）。客户端程序通过对象生成器类 ReadXML 读取 XML 配置文件中的装修方案数据（点此下载 XML 文件），调用项目经理进行装修。其类图如图 2 所示。
程序代码如下：
package Builder;import java.awt.*;import javax.swing.*;public class ParlourDecorator {public static void main(String[] args) {try {Decorator d;d = (Decorator) ReadXML.getObject();ProjectManager m = new ProjectManager(d);Parlour p = m.decorate();p.show();} catch (Exception e) {System.out.println(e.getMessage());}}}//产品：客厅class Parlour {private String wall; //墙private String TV; //电视private String sofa; //沙发public void setWall(String wall) {this.wall = wall;}public void setTV(String TV) {this.TV = TV;}public void setSofa(String sofa) {this.sofa = sofa;}public void show() {JFrame jf = new JFrame("建造者模式测试");Container contentPane = jf.getContentPane();JPanel p = new JPanel();JScrollPane sp = new JScrollPane(p);String parlour = wall + TV + sofa;JLabel l = new JLabel(new ImageIcon("src/" + parlour + ".jpg"));p.setLayout(new GridLayout(1, 1));p.setBorder(BorderFactory.createTitledBorder("客厅"));p.add(l);contentPane.add(sp, BorderLayout.CENTER);jf.pack();jf.setVisible(true);jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}}//抽象建造者：装修工人abstract class Decorator {//创建产品对象protected Parlour product = new Parlour();public abstract void buildWall();public abstract void buildTV();public abstract void buildSofa();//返回产品对象public Parlour getResult() {return product;}}//具体建造者：具体装修工人1class ConcreteDecorator1 extends Decorator {public void buildWall() {product.setWall("w1");}public void buildTV() {product.setTV("TV1");}public void buildSofa() {product.setSofa("sf1");}}//具体建造者：具体装修工人2class ConcreteDecorator2 extends Decorator {public void buildWall() {product.setWall("w2");}public void buildTV() {product.setTV("TV2");}public void buildSofa() {product.setSofa("sf2");}}//指挥者：项目经理class ProjectManager {private Decorator builder;public ProjectManager(Decorator builder) {this.builder = builder;}//产品构建与组装方法public Parlour decorate() {builder.buildWall();builder.buildTV();builder.buildSofa();return builder.getResult();}}package Builder;import org.w3c.dom.Document;import org.w3c.dom.Node;import org.w3c.dom.NodeList;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import java.io.File;class ReadXML {public static Object getObject() {try {DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();DocumentBuilder builder = dFactory.newDocumentBuilder();Document doc;doc = builder.parse(new File("src/Builder/config.xml"));NodeList nl = doc.getElementsByTagName("className");Node classNode = nl.item(0).getFirstChild();String cName = "Builder." + classNode.getNodeValue();System.out.println("新类名：" + cName);Class<?> c = Class.forName(cName);Object obj = c.newInstance();return obj;} catch (Exception e) {e.printStackTrace();return null;}}}
模式的应用场景
建造者模式唯一区别于工厂模式的是针对复杂对象的创建。也就是说，如果创建简单对象，通常都是使用工厂模式进行创建，而如果创建复杂对象，就可以考虑使用建造者模式。
当需要创建的产品具备复杂创建过程时，可以抽取出共性创建过程，然后交由具体实现类自定义创建流程，使得同样的创建行为可以生产出不同的产品，分离了创建与表示，使创建产品的灵活性大大增加。
建造者模式主要适用于以下应用场景：
- 相同的方法，不同的执行顺序，产生不同的结果。
- 多个部件或零件，都可以装配到一个对象中，但是产生的结果又不相同。
- 产品类非常复杂，或者产品类中不同的调用顺序产生不同的作用。
-
建造者模式和工厂模式的区别
通过前面的学习，我们已经了解了建造者模式，那么它和工厂模式有什么区别呢？
建造者模式更加注重方法的调用顺序，工厂模式注重创建对象。
- 创建对象的力度不同，建造者模式创建复杂的对象，由各种复杂的部件组成，工厂模式创建出来的对象都一样
- 关注重点不一样，工厂模式只需要把对象创建出来就可以了，而建造者模式不仅要创建出对象，还要知道对象由哪些部件组成。
建造者模式根据建造过程中的顺序不一样，最终对象部件组成也不一样。
模式的扩展
建造者（Builder）模式在应用过程中可以根据需要改变，如果创建的产品种类只有一种，只需要一个具体建造者，这时可以省略掉抽象建造者，甚至可以省略掉指挥者角色。
进阶阅读
如果您想了解建造者模式在实际项目中的应用，可猛击阅读以下文章。
- 《使用静态内部类实现建造者模式》
- 《使用建造者模式构建动态SQL语句》
- 《建造者模式在框架源码中的应用》
创建型模式应运试验
参考：http://c.biancheng.net/view/1408.html结构型
结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者釆用组合或聚合来组合对象。
由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性。
结构型模式分为以下 7 种：
- 代理（Proxy）模式：为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性。
- 适配器（Adapter）模式：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
- 桥接（Bridge）模式：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现的，从而降低了抽象和实现这两个可变维度的耦合度。
- 装饰（Decorator）模式：动态地给对象增加一些职责，即增加其额外的功能。
- 外观（Facade）模式：为多个复杂的子系统提供一个一致的接口，使这些子系统更加容易被访问。
- 享元（Flyweight）模式：运用共享技术来有效地支持大量细粒度对象的复用。
- 组合（Composite）模式：将对象组合成树状层次结构，使用户对单个对象和组合对象具有一致的访问性。
以上 7 种结构型模式，除了适配器模式分为类结构型模式和对象结构型模式两种，其他的全部属于对象结构型模式，下面我们会分别、详细地介绍它们的特点、结构与应用。代理模式(先不看)
在有些情况下，一个客户不能或者不想直接访问另一个对象，这时需要找一个中介帮忙完成某项任务，这个中介就是代理对象。例如，购买火车票不一定要去火车站买，可以通过 12306 网站或者去火车票代售点买。又如找女朋友、找保姆、找工作等都可以通过找中介完成。
在软件设计中，使用代理模式的例子也很多，例如，要访问的远程对象比较大（如视频或大图像等），其下载要花很多时间。还有因为安全原因需要屏蔽客户端直接访问真实对象，如某单位的内部数据库等。适配器模式(Adapter模式)详解
行为型
观察者模式
在现实世界中，许多对象并不是独立存在的，其中一个对象的行为发生改变可能会导致一个或者多个其他对象的行为也发生改变。例如，某种商品的物价上涨时会导致部分商家高兴，而消费者伤心；还有，当我们开车到交叉路口时，遇到红灯会停，遇到绿灯会行。这样的例子还有很多，例如，股票价格与股民、微信公众号与微信用户、气象局的天气预报与听众、小偷与警察等。
在软件世界也是这样，例如，Excel 中的数据与折线图、饼状图、柱状图之间的关系；MVC 模式中的模型与视图的关系；事件模型中的事件源与事件处理者。所有这些，如果用观察者模式来实现就非常方便。
模式的定义与特点
观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。
观察者模式是一种对象行为型模式，其主要优点如下。
- 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。符合依赖倒置原则。
- 目标与观察者之间建立了一套触发机制。
它的主要缺点如下。 - 目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。
模式的结构与实现
实现观察者模式时要注意具体目标对象和具体观察者对象之间不能直接调用，否则将使两者之间紧密耦合起来，这违反了面向对象的设计原则。
1. 模式的结构
观察者模式的主要角色如下。
抽象主题（Subject）角色：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。
- 具体主题（Concrete Subject）角色：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
- 抽象观察者（Observer）角色：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
- 具体观察者（Concrete Observer）角色：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。
观察者模式的结构图如图 1 所示。
2. 模式的实现
观察者模式的实现代码如下：
package net.biancheng.c.observer;import java.util.*;public class ObserverPattern {public static void main(String[] args) {Subject subject = new ConcreteSubject();Observer obs1 = new ConcreteObserver1();Observer obs2 = new ConcreteObserver2();subject.add(obs1);subject.add(obs2);subject.notifyObserver();}}//抽象目标abstract class Subject {protected List<Observer> observers = new ArrayList<Observer>();//增加观察者方法public void add(Observer observer) {observers.add(observer);}//删除观察者方法public void remove(Observer observer) {observers.remove(observer);}public abstract void notifyObserver(); //通知观察者方法}//具体目标class ConcreteSubject extends Subject {public void notifyObserver() {System.out.println("具体目标发生改变...");System.out.println("--------------");for (Object obs : observers) {((Observer) obs).response();}}}//抽象观察者interface Observer {void response(); //反应}//具体观察者1class ConcreteObserver1 implements Observer {public void response() {System.out.println("具体观察者1作出反应！");}}//具体观察者1class ConcreteObserver2 implements Observer {public void response() {System.out.println("具体观察者2作出反应！");}}
程序运行结果如下：
具体目标发生改变...--------------具体观察者1作出反应！具体观察者2作出反应！
模式的应用实例
【例1】利用观察者模式设计一个程序，分析“人民币汇率”的升值或贬值对进口公司进口产品成本或出口公司的出口产品收入以及公司利润率的影响。
分析：当“人民币汇率”升值时，进口公司的进口产品成本降低且利润率提升，出口公司的出口产品收入降低且利润率降低；当“人民币汇率”贬值时，进口公司的进口产品成本提升且利润率降低，出口公司的出口产品收入提升且利润率提升。这里的汇率（Rate）类是抽象目标类，它包含了保存观察者（Company）的 List 和增加/删除观察者的方法，以及有关汇率改变的抽象方法 change(int number)；而人民币汇率（RMBrate）类是具体目标， 它实现了父类的 change(int number) 方法，即当人民币汇率发生改变时通过相关公司；公司（Company）类是抽象观察者，它定义了一个有关汇率反应的抽象方法 response(int number)；进口公司（ImportCompany）类和出口公司（ExportCompany）类是具体观察者类，它们实现了父类的 response(int number) 方法，即当它们接收到汇率发生改变的通知时作为相应的反应。图 2 所示是其结构图。<br /><br />程序代码如下：
package net.biancheng.c.observer;import java.util.*;public class RMBrateTest {public static void main(String[] args) {Rate rate = new RMBrate();Company watcher1 = new ImportCompany();Company watcher2 = new ExportCompany();rate.add(watcher1);rate.add(watcher2);rate.change(10);rate.change(-9);}}//抽象目标：汇率abstract class Rate {protected List<Company> companys = new ArrayList<Company>();//增加观察者方法public void add(Company company) {companys.add(company);}//删除观察者方法public void remove(Company company) {companys.remove(company);}public abstract void change(int number);}//具体目标：人民币汇率class RMBrate extends Rate {public void change(int number) {for (Company obs : companys) {((Company) obs).response(number);}}}//抽象观察者：公司interface Company {void response(int number);}//具体观察者1：进口公司class ImportCompany implements Company {public void response(int number) {if (number > 0) {System.out.println("人民币汇率升值" + number + "个基点，降低了进口产品成本，提升了进口公司利润率。");} else if (number < 0) {System.out.println("人民币汇率贬值" + (-number) + "个基点，提升了进口产品成本，降低了进口公司利润率。");}}}//具体观察者2：出口公司class ExportCompany implements Company {public void response(int number) {if (number > 0) {System.out.println("人民币汇率升值" + number + "个基点，降低了出口产品收入，降低了出口公司的销售利润率。");} else if (number < 0) {System.out.println("人民币汇率贬值" + (-number) + "个基点，提升了出口产品收入，提升了出口公司的销售利润率。");}}}
程序运行结果如下：
人民币汇率升值10个基点，降低了进口产品成本，提升了进口公司利润率。人民币汇率升值10个基点，降低了出口产品收入，降低了出口公司的销售利润率。人民币汇率贬值9个基点，提升了进口产品成本，降低了进口公司利润率。人民币汇率贬值9个基点，提升了出口产品收入，提升了出口公司的销售利润率。
观察者模式在软件幵发中用得最多的是窗体程序设计中的事件处理，窗体中的所有组件都是“事件源”，也就是目标对象，而事件处理程序类的对象是具体观察者对象。下面以一个学校铃声的事件处理程序为例，介绍 Windows 中的“事件处理模型”的工作原理。
【例2】利用观察者模式设计一个学校铃声的事件处理程序。
分析：在本实例中，学校的“铃”是事件源和目标，“老师”和“学生”是事件监听器和具体观察者，“铃声”是事件类。学生和老师来到学校的教学区，都会注意学校的铃，这叫事件绑定；当上课时间或下课时间到，会触发铃发声，这时会生成“铃声”事件；学生和老师听到铃声会开始上课或下课，这叫事件处理。这个实例非常适合用观察者模式实现，图 3 给出了学校铃声的事件模型。
现在用“观察者模式”来实现该事件处理模型。
首先，定义一个铃声事件（RingEvent）类，它记录了铃声的类型（上课铃声/下课铃声）。
再定义一个学校的铃（BellEventSource）类，它是事件源，是观察者目标类，该类里面包含了监听器容器 listener，可以绑定监听者（学生或老师），并且有产生铃声事件和通知所有监听者的方法。
然后，定义铃声事件监听者（BellEventListener）类，它是抽象观察者，它包含了铃声事件处理方法 heardBell(RingEvent e)。
最后，定义老师类（TeachEventListener）和学生类（StuEventListener），它们是事件监听器，是具体观察者，听到铃声会去上课或下课。图 4 给出了学校铃声事件处理程序的结构。
程序代码如下：
package net.biancheng.c.observer;import java.util.*;public class BellEventTest {public static void main(String[] args) {BellEventSource bell = new BellEventSource(); //铃（事件源）bell.addPersonListener(new TeachEventListener()); //注册监听器（老师）bell.addPersonListener(new StuEventListener()); //注册监听器（学生）bell.ring(true); //打上课铃声System.out.println("------------");bell.ring(false); //打下课铃声}}//铃声事件类：用于封装事件源及一些与事件相关的参数class RingEvent extends EventObject {private static final long serialVersionUID = 1L;private boolean sound; //true表示上课铃声,false表示下课铃声public RingEvent(Object source, boolean sound) {super(source);this.sound = sound;}public void setSound(boolean sound) {this.sound = sound;}public boolean getSound() {return this.sound;}}//目标类：事件源，铃class BellEventSource {private List<BellEventListener> listener; //监听器容器public BellEventSource() {listener = new ArrayList<BellEventListener>();}//给事件源绑定监听器public void addPersonListener(BellEventListener ren) {listener.add(ren);}//事件触发器：敲钟，当铃声sound的值发生变化时，触发事件。public void ring(boolean sound) {String type = sound ? "上课铃" : "下课铃";System.out.println(type + "响！");RingEvent event = new RingEvent(this, sound);notifies(event); //通知注册在该事件源上的所有监听器}//当事件发生时,通知绑定在该事件源上的所有监听器做出反应（调用事件处理方法）protected void notifies(RingEvent e) {BellEventListener ren = null;Iterator<BellEventListener> iterator = listener.iterator();while (iterator.hasNext()) {ren = iterator.next();ren.heardBell(e);}}}//抽象观察者类：铃声事件监听器interface BellEventListener extends EventListener {//事件处理方法，听到铃声public void heardBell(RingEvent e);}//具体观察者类：老师事件监听器class TeachEventListener implements BellEventListener {public void heardBell(RingEvent e) {if (e.getSound()) {System.out.println("老师上课了...");} else {System.out.println("老师下课了...");}}}//具体观察者类：学生事件监听器class StuEventListener implements BellEventListener {public void heardBell(RingEvent e) {if (e.getSound()) {System.out.println("同学们，上课了...");} else {System.out.println("同学们，下课了...");}}}
程序运行结果如下：
上课铃响！老师上课了...同学们，上课了...------------下课铃响！老师下课了...同学们，下课了...
模式的应用场景
在软件系统中，当系统一方行为依赖另一方行为的变动时，可使用观察者模式松耦合联动双方，使得一方的变动可以通知到感兴趣的另一方对象，从而让另一方对象对此做出响应。
通过前面的分析与应用实例可知观察者模式适合以下几种情形。
- 对象间存在一对多关系，一个对象的状态发生改变会影响其他对象。
- 当一个抽象模型有两个方面，其中一个方面依赖于另一方面时，可将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
- 实现类似广播机制的功能，不需要知道具体收听者，只需分发广播，系统中感兴趣的对象会自动接收该广播。
- 多层级嵌套使用，形成一种链式触发机制，使得事件具备跨域（跨越两种观察者类型）通知。
模式的扩展
在 Java 中，通过 java.util.Observable 类和 java.util.Observer 接口定义了观察者模式，只要实现它们的子类就可以编写观察者模式实例。
1. Observable类
Observable 类是抽象目标类，它有一个 Vector 向量，用于保存所有要通知的观察者对象，下面来介绍它最重要的 3 个方法。
- void addObserver(Observer o) 方法：用于将新的观察者对象添加到向量中。
- void notifyObservers(Object arg) 方法：调用向量中的所有观察者对象的 update() 方法，通知它们数据发生改变。通常越晚加入向量的观察者越先得到通知。
- void setChange() 方法：用来设置一个 boolean 类型的内部标志位，注明目标对象发生了变化。当它为真时，notifyObservers() 才会通知观察者。
2. Observer 接口
Observer 接口是抽象观察者，它监视目标对象的变化，当目标对象发生变化时，观察者得到通知，并调用 void update(Observable o,Object arg) 方法，进行相应的工作。
【例3】利用 Observable 类和 Observer 接口实现原油期货的观察者模式实例。
分析：当原油价格上涨时，空方伤心，多方局兴；当油价下跌时，空方局兴，多方伤心。本实例中的抽象目标（Observable）类在 Java 中已经定义，可以直接定义其子类，即原油期货（OilFutures）类，它是具体目标类，该类中定义一个 SetPriCe(float price) 方法，当原油数据发生变化时调用其父类的 notifyObservers(Object arg) 方法来通知所有观察者；另外，本实例中的抽象观察者接口（Observer）在 Java 中已经定义，只要定义其子类，即具体观察者类（包括多方类 Bull 和空方类 Bear），并实现 update(Observable o,Object arg) 方法即可。图 5 所示是其结构图。
程序代码如下：
package net.biancheng.c.observer;import java.util.Observer;import java.util.Observable;public class CrudeOilFutures {public static void main(String[] args) {OilFutures oil = new OilFutures();Observer bull = new Bull(); //多方Observer bear = new Bear(); //空方oil.addObserver(bull);oil.addObserver(bear);oil.setPrice(10);oil.setPrice(-8);}}//具体目标类：原油期货class OilFutures extends Observable {private float price;public float getPrice() {return this.price;}public void setPrice(float price) {super.setChanged(); //设置内部标志位，注明数据发生变化super.notifyObservers(price); //通知观察者价格改变了this.price = price;}}//具体观察者类：多方class Bull implements Observer {public void update(Observable o, Object arg) {Float price = ((Float) arg).floatValue();if (price > 0) {System.out.println("油价上涨" + price + "元，多方高兴了！");} else {System.out.println("油价下跌" + (-price) + "元，多方伤心了！");}}}//具体观察者类：空方class Bear implements Observer {public void update(Observable o, Object arg) {Float price = ((Float) arg).floatValue();if (price > 0) {System.out.println("油价上涨" + price + "元，空方伤心了！");} else {System.out.println("油价下跌" + (-price) + "元，空方高兴了！");}}}
程序运行结果如下：
油价上涨10.0元，空方伤心了！油价上涨10.0元，多方高兴了！油价下跌8.0元，空方高兴了！油价下跌8.0元，多方伤心了！
进阶阅读
如果您想了解观察者模式在实际项目中的应用，可猛击阅读《基于Java API实现通知机制》文章。
若有收获，就点个赞吧
0 人点赞
