结构型模式概述（结构型模式的分类）

结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者釆用组合或聚合来组合对象。

由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性。

结构型模式分为以下 7 种：

1. 代理（Proxy）模式：为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性。
2. 适配器（Adapter）模式：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
3. 桥接（Bridge）模式：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现的，从而降低了抽象和实现这两个可变维度的耦合度。
4. 装饰（Decorator）模式：动态地给对象增加一些职责，即增加其额外的功能。
5. 外观（Facade）模式：为多个复杂的子系统提供一个一致的接口，使这些子系统更加容易被访问。
6. 享元（Flyweight）模式：运用共享技术来有效地支持大量细粒度对象的复用。
7. 组合（Composite）模式：将对象组合成树状层次结构，使用户对单个对象和组合对象具有一致的访问性。

以上 7 种结构型模式，除了适配器模式分为类结构型模式和对象结构型模式两种，其他的全部属于对象结构型模式，下面我们会分别、详细地介绍它们的特点、结构与应用。

6.代理模式（代理设计模式）

在有些情况下，一个客户不能或者不想直接访问另一个对象，这时需要找一个中介帮忙完成某项任务，这个中介就是代理对象。例如，购买火车票不一定要去火车站买，可以通过 12306 网站或者去火车票代售点买。又如找女朋友、找保姆、找工作等都可以通过找中介完成。

在软件设计中，使用代理模式的例子也很多，例如，要访问的远程对象比较大（如视频或大图像等），其下载要花很多时间。还有因为安全原因需要屏蔽客户端直接访问真实对象，如某单位的内部数据库等。

代理模式的定义与特点

代理模式的定义：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。

代理模式的主要优点有：

• 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
• 代理对象可以扩展目标对象的功能；
• 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度；

其主要缺点是：

• 在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢；
• 增加了系统的复杂度；

代理模式的结构与实现

代理模式的结构比较简单，主要是通过定义一个继承抽象主题的代理来包含真实主题，从而实现对真实主题的访问，下面来分析其基本结构和实现方法。

1. 模式的结构

代理模式的主要角色如下。

1. 抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
2. 真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
3. 代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。

其结构图如图 1 所示。

图1 代理模式的结构图

2. 模式的实现

代理模式的实现代码如下：

package proxy;
public class ProxyTest
{
public static void main(String[] args)
{
Proxy proxy=new Proxy();
proxy.Request();
}
}
//抽象主题
interface Subject
{
void Request();
}
//真实主题
class RealSubject implements Subject
{
public void Request()
{
System.out.println("访问真实主题方法...");
}
}
//代理
class Proxy implements Subject
{
private RealSubject realSubject;
public void Request()
{
if (realSubject==null)
{
realSubject=new RealSubject();
}
preRequest();
realSubject.Request();
postRequest();
}
public void preRequest()
{
System.out.println("访问真实主题之前的预处理。");
}
public void postRequest()
{
System.out.println("访问真实主题之后的后续处理。");
}
}

程序运行的结果如下：
访问真实主题之前的预处理。
访问真实主题方法…
访问真实主题之后的后续处理。

代理模式的应用实例

【例1】韶关“天街e角”公司是一家婺源特产公司的代理公司，用代理模式实现。

分析：本实例中的“婺源特产公司”经营许多婺源特产，它是真实主题，提供了显示特产的 display() 方法，可以用窗体程序实现（点此下载该实例所要显示的图片）。而韶关“天街e角”公司是婺源特产公司特产的代理，通过调用婺源特产公司的 display() 方法显示代理产品，当然它可以增加一些额外的处理，如包裝或加价等。客户可通过“天街e角”代理公司间接访问“婺源特产公司”的产品，图 2 所示是公司的结构图。

图2 韶关“天街e角”公司的结构图

程序代码如下：

package proxy;
import java.awt.*;
import javax.swing.*;
public class WySpecialtyProxy
{
public static void main(String[] args)
{
SgProxy proxy=new SgProxy();
proxy.display();
}
}
//抽象主题：特产
interface Specialty
{
void display();
}
//真实主题：婺源特产
class WySpecialty extends JFrame implements Specialty
{
private static final long serialVersionUID=1L;
public WySpecialty()
{
super("韶关代理婺源特产测试");
this.setLayout(new GridLayout(1,1));
JLabel l1=new JLabel(new ImageIcon("src/proxy/WuyuanSpecialty.jpg"));
this.add(l1);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public void display()
{
this.setVisible(true);
}
}
//代理：韶关代理
class SgProxy implements Specialty
{
private WySpecialty realSubject=new WySpecialty();
public void display()
{
preRequest();
realSubject.display();
postRequest();
}
public void preRequest()
{
System.out.println("韶关代理婺源特产开始。");
}
public void postRequest()
{
System.out.println("韶关代理婺源特产结束。");
}
}

程序运行结果如图 3 所示。

图3 韶关“天街e角”公司的代理产品

代理模式的应用场景

前面分析了代理模式的结构与特点，现在来分析以下的应用场景。

• 远程代理，这种方式通常是为了隐藏目标对象存在于不同地址空间的事实，方便客户端访问。例如，用户申请某些网盘空间时，会在用户的文件系统中建立一个虚拟的硬盘，用户访问虚拟硬盘时实际访问的是网盘空间。
• 虚拟代理，这种方式通常用于要创建的目标对象开销很大时。例如，下载一幅很大的图像需要很长时间，因某种计算比较复杂而短时间无法完成，这时可以先用小比例的虚拟代理替换真实的对象，消除用户对服务器慢的感觉。
• 安全代理，这种方式通常用于控制不同种类客户对真实对象的访问权限。
• 智能指引，主要用于调用目标对象时，代理附加一些额外的处理功能。例如，增加计算真实对象的引用次数的功能，这样当该对象没有被引用时，就可以自动释放它。
• 延迟加载，指为了提高系统的性能，延迟对目标的加载。例如，Hibernate 中就存在属性的延迟加载和关联表的延时加载。

代理模式的扩展

在前面介绍的代理模式中，代理类中包含了对真实主题的引用，这种方式存在两个缺点。

1. 真实主题与代理主题一一对应，增加真实主题也要增加代理。
2. 设计代理以前真实主题必须事先存在，不太灵活。采用动态代理模式可以解决以上问题，如 SpringAOP，其结构图如图 4 所示。

图4 动态代理模式的结构图

7.适配器模式（Adapter模式）

在现实生活中，经常出现两个对象因接口不兼容而不能在一起工作的实例，这时需要第三者进行适配。例如，讲中文的人同讲英文的人对话时需要一个翻译，用直流电的笔记本电脑接交流电源时需要一个电源适配器，用计算机访问照相机的 SD 内存卡时需要一个读卡器等。

在软件设计中也可能出现：需要开发的具有某种业务功能的组件在现有的组件库中已经存在，但它们与当前系统的接口规范不兼容，如果重新开发这些组件成本又很高，这时用适配器模式能很好地解决这些问题。

模式的定义与特点

适配器模式（Adapter）的定义如下：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。适配器模式分为类结构型模式和对象结构型模式两种，前者类之间的耦合度比后者高，且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少些。

该模式的主要优点如下。

• 客户端通过适配器可以透明地调用目标接口。
• 复用了现存的类，程序员不需要修改原有代码而重用现有的适配者类。
• 将目标类和适配者类解耦，解决了目标类和适配者类接口不一致的问题。

其缺点是：对类适配器来说，更换适配器的实现过程比较复杂。

模式的结构与实现

类适配器模式可采用多重继承方式实现，如 C++ 可定义一个适配器类来同时继承当前系统的业务接口和现有组件库中已经存在的组件接口；Java 不支持多继承，但可以定义一个适配器类来实现当前系统的业务接口，同时又继承现有组件库中已经存在的组件。

对象适配器模式可釆用将现有组件库中已经实现的组件引入适配器类中，该类同时实现当前系统的业务接口。现在来介绍它们的基本结构。

1. 模式的结构

适配器模式（Adapter）包含以下主要角色。

1. 目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口。
2. 适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口。
3. 适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。

类适配器模式的结构图如图 1 所示。

图1 类适配器模式的结构图

对象适配器模式的结构图如图 2 所示。

图2 对象适配器模式的结构图

2. 模式的实现

(1) 类适配器模式的代码如下。

package adapter;
//目标接口
interface Target
{
public void request();
}
//适配者接口
class Adaptee
{
 public void specificRequest()
 {
 System.out.println("适配者中的业务代码被调用！");
 }
 }
 //类适配器类
 class ClassAdapter extends Adaptee implements Target
 {
 public void request()
 {
 specificRequest();
 }
 }
 //客户端代码
 public class ClassAdapterTest
 {
 public static void main(String[] args)
 {
 System.out.println("类适配器模式测试：");
 Target target = new ClassAdapter();
 target.request();
 }
 }

程序的运行结果如下：
类适配器模式测试：
适配者中的业务代码被调用！

(2)对象适配器模式的代码如下。

package adapter;
//对象适配器类
class ObjectAdapter implements Target
{
private Adaptee adaptee;
public ObjectAdapter(Adaptee adaptee)
{
this.adaptee=adaptee;
}
public void request()
{
adaptee.specificRequest();
}
}
//客户端代码
public class ObjectAdapterTest
{
public static void main(String[] args)
{
System.out.println("对象适配器模式测试：");
Adaptee adaptee = new Adaptee();
Target target = new ObjectAdapter(adaptee);
target.request();
}
}

说明：对象适配器模式中的“目标接口”和“适配者类”的代码同类适配器模式一样，只要修改适配器类和客户端的代码即可。

程序的运行结果如下：
对象适配器模式测试：
适配者中的业务代码被调用！

模式的应用实例

【例1】用适配器模式（Adapter）模拟新能源汽车的发动机。

分析：新能源汽车的发动机有电能发动机（Electric Motor）和光能发动机（Optical Motor）等，各种发动机的驱动方法不同，例如，电能发动机的驱动方法 electricDrive() 是用电能驱动，而光能发动机的驱动方法 opticalDrive() 是用光能驱动，它们是适配器模式中被访问的适配者。

客户端希望用统一的发动机驱动方法 drive() 访问这两种发动机，所以必须定义一个统一的目标接口 Motor，然后再定义电能适配器（Electric Adapter）和光能适配器（Optical Adapter）去适配这两种发动机。

我们把客户端想访问的新能源发动机的适配器的名称放在 XML 配置文件中（点此下载 XML 文件），客户端可以通过对象生成器类 ReadXML 去读取。这样，客户端就可以通过 Motor 接口随便使用任意一种新能源发动机去驱动汽车，图 3 所示是其结构图。

图3 发动机适配器的结构图

程序代码如下：

package adapter;
//目标：发动机
interface Motor
{
public void drive();
}
//适配者1：电能发动机
class ElectricMotor
{
public void electricDrive()
{
System.out.println("电能发动机驱动汽车！");
}
}
//适配者2：光能发动机
class OpticalMotor
{
public void opticalDrive()
{
System.out.println("光能发动机驱动汽车！");
}
}
//电能适配器
class ElectricAdapter implements Motor
{
private ElectricMotor emotor;
public ElectricAdapter()
{
emotor=new ElectricMotor();
}
public void drive()
{
emotor.electricDrive();
}
}
//光能适配器
class OpticalAdapter implements Motor
{
private OpticalMotor omotor;
public OpticalAdapter()
{
omotor=new OpticalMotor();
}
public void drive()
{
omotor.opticalDrive();
}
}
//客户端代码
public class MotorAdapterTest
{
public static void main(String[] args)
{
System.out.println("适配器模式测试：");
Motor motor=(Motor)ReadXML.getObject();
motor.drive();
}
}
package adapter;
import javax.xml.parsers.*;
import org.w3c.dom.*;
import java.io.*;
class ReadXML
{
public static Object getObject()
{
try
{
DocumentBuilderFactory dFactory=DocumentBuilderFactory.newInstance();
DocumentBuilder builder=dFactory.newDocumentBuilder();
Document doc;
doc=builder.parse(new File("src/adapter/config.xml"));
NodeList nl=doc.getElementsByTagName("className");
Node classNode=nl.item(0).getFirstChild();
String cName="adapter."+classNode.getNodeValue();
Class<?> c=Class.forName(cName);
Object obj=c.newInstance();
return obj;
}
catch(Exception e)
{
e.printStackTrace();
return null;
}
}
}

程序的运行结果如下：
适配器模式测试：
电能发动机驱动汽车！

注意：如果将配置文件中的 ElectricAdapter 改为 OpticalAdapter，则运行结果如下：
适配器模式测试：
光能发动机驱动汽车！

模式的应用场景

适配器模式（Adapter）通常适用于以下场景。

• 以前开发的系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致。
• 使用第三方提供的组件，但组件接口定义和自己要求的接口定义不同。

模式的扩展

适配器模式（Adapter）可扩展为双向适配器模式，双向适配器类既可以把适配者接口转换成目标接口，也可以把目标接口转换成适配者接口，其结构图如图 4 所示。

图4 双向适配器模式的结构图

程序代码如下：

package adapter;
//目标接口
interface TwoWayTarget
{
public void request();
}
//适配者接口
interface TwoWayAdaptee
{
public void specificRequest();
}
//目标实现
class TargetRealize implements TwoWayTarget
{
public void request()
{
System.out.println("目标代码被调用！");
}
}
//适配者实现
class AdapteeRealize implements TwoWayAdaptee
{
public void specificRequest()
{
System.out.println("适配者代码被调用！");
}
}
//双向适配器
class TwoWayAdapter  implements TwoWayTarget,TwoWayAdaptee
{
private TwoWayTarget target;
private TwoWayAdaptee adaptee;
public TwoWayAdapter(TwoWayTarget target)
{
this.target=target;
}
public TwoWayAdapter(TwoWayAdaptee adaptee)
{
this.adaptee=adaptee;
}
public void request()
{
adaptee.specificRequest();
}
public void specificRequest()
{
target.request();
}
}
//客户端代码
public class TwoWayAdapterTest
{
public static void main(String[] args)
{
System.out.println("目标通过双向适配器访问适配者：");
TwoWayAdaptee adaptee=new AdapteeRealize();
TwoWayTarget target=new TwoWayAdapter(adaptee);
target.request();
System.out.println("-------------------");
System.out.println("适配者通过双向适配器访问目标：");
target=new TargetRealize();
adaptee=new TwoWayAdapter(target);
adaptee.specificRequest();
}
}

程序的运行结果如下：

目标通过双向适配器访问适配者：

适配者代码被调用！

适配者通过双向适配器访问目标：
目标代码被调用！

8.桥接模式（Bridge模式）

在现实生活中，某些类具有两个或多个维度的变化，如图形既可按形状分，又可按颜色分。如何设计类似于 Photoshop 这样的软件，能画不同形状和不同颜色的图形呢？如果用继承方式，m 种形状和 n 种颜色的图形就有 m×n 种，不但对应的子类很多，而且扩展困难。

当然，这样的例子还有很多，如不同颜色和字体的文字、不同品牌和功率的汽车、不同性别和职业的男女、支持不同平台和不同文件格式的媒体播放器等。如果用桥接模式就能很好地解决这些问题。

桥接模式的定义与特点

桥接（Bridge）模式的定义如下：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。

桥接（Bridge）模式的优点是：

• 由于抽象与实现分离，所以扩展能力强；
• 其实现细节对客户透明。

缺点是：由于聚合关系建立在抽象层，要求开发者针对抽象化进行设计与编程，这增加了系统的理解与设计难度。

桥接模式的结构与实现

可以将抽象化部分与实现化部分分开，取消二者的继承关系，改用组合关系。

1. 模式的结构

桥接（Bridge）模式包含以下主要角色。

1. 抽象化（Abstraction）角色：定义抽象类，并包含一个对实现化对象的引用。
2. 扩展抽象化（Refined Abstraction）角色：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法。
3. 实现化（Implementor）角色：定义实现化角色的接口，供扩展抽象化角色调用。
4. 具体实现化（Concrete Implementor）角色：给出实现化角色接口的具体实现。

其结构图如图 1 所示。

图1 桥接模式的结构图

2. 模式的实现

桥接模式的代码如下：

1. package bridge;
2. public class BridgeTest
3. {
4. public static void main(String[] args)
5. {
6. Implementor imple=new ConcreteImplementorA();
7. Abstraction abs=new RefinedAbstraction(imple);
8. abs.Operation();
9. }
10. }
11. //实现化角色
12. interface Implementor
13. {
14. public void OperationImpl();
15. }
16. //具体实现化角色
17. class ConcreteImplementorA implements Implementor
18. {
19. public void OperationImpl()
20. {
21. System.out.println("具体实现化(Concrete Implementor)角色被访问" );
22. }
23. }
24. //抽象化角色
25. abstract class Abstraction
26. {
27. protected Implementor imple;
28. protected Abstraction(Implementor imple)
29. {
30. this.imple=imple;
31. }
32. public abstract void Operation();
33. }
34. //扩展抽象化角色
35. class RefinedAbstraction extends Abstraction
36. {
37. protected RefinedAbstraction(Implementor imple)
38. {
39. super(imple);
40. }
41. public void Operation()
42. {
43. System.out.println("扩展抽象化(Refined Abstraction)角色被访问" );
44. imple.OperationImpl();
45. }
46. }

程序的运行结果如下：
扩展抽象化(Refined Abstraction)角色被访问
具体实现化(Concrete Implementor)角色被访问

桥接模式的应用实例

【例1】用桥接（Bridge）模式模拟女士皮包的选购。

分析：女士皮包有很多种，可以按用途分、按皮质分、按品牌分、按颜色分、按大小分等，存在多个维度的变化，所以采用桥接模式来实现女士皮包的选购比较合适。

本实例按用途分可选钱包（Wallet）和挎包（HandBag），按颜色分可选黄色（Yellow）和红色（Red）。可以按两个维度定义为颜色类和包类。（点此下载本实例所要显示的包的图片）。

颜色类（Color）是一个维度，定义为实现化角色，它有两个具体实现化角色：黄色和红色，通过 getColor() 方法可以选择颜色；包类（Bag）是另一个维度，定义为抽象化角色，它有两个扩展抽象化角色：挎包和钱包，它包含了颜色类对象，通过 getName() 方法可以选择相关颜色的挎包和钱包。

客户类通过 ReadXML 类从 XML 配置文件中获取包信息（点此下载 XML 配置文件），并把选到的产品通过窗体显示出现，图 2 所示是其结构图。

图2 女士皮包选购的结构图

程序代码如下：

package bridge;
import java.awt.*;
import javax.swing.*;
public class BagManage
{
public static void main(String[] args)
{
Color color;
Bag bag;
color=(Color)ReadXML.getObject("color");
bag=(Bag)ReadXML.getObject("bag");
bag.setColor(color);
String name=bag.getName();
show(name);
}
public static void show(String name)
{
JFrame jf=new JFrame("桥接模式测试");
Container contentPane=jf.getContentPane();
JPanel p=new JPanel();
JLabel l=new JLabel(new ImageIcon("src/bridge/"+name+".jpg"));
p.setLayout(new GridLayout(1,1));
p.setBorder(BorderFactory.createTitledBorder("女士皮包"));
p.add(l);
contentPane.add(p, BorderLayout.CENTER);
jf.pack();
jf.setVisible(true);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
//实现化角色：颜色
interface Color
{
String getColor();
}
//具体实现化角色：黄色
class Yellow implements Color
{
public String getColor()
{
return "yellow";
}
}
//具体实现化角色：红色
class Red implements Color
{
public String getColor()
{
return "red";
}
}
//抽象化角色：包
abstract class Bag
{
protected Color color;
public void setColor(Color color)
{
this.color=color;
}
public abstract String getName();
}
//扩展抽象化角色：挎包
class HandBag extends Bag
{
public String getName()
{
return color.getColor()+"HandBag";
}
}
//扩展抽象化角色：钱包
class Wallet extends Bag
{
public String getName()
{
return color.getColor()+"Wallet";
}
}
package bridge;
import javax.xml.parsers.*;
import org.w3c.dom.*;
import java.io.*;
class ReadXML
{
public static Object getObject(String args)
{
try
{
DocumentBuilderFactory dFactory=DocumentBuilderFactory.newInstance();
DocumentBuilder builder=dFactory.newDocumentBuilder();
Document doc;
doc=builder.parse(new File("src/bridge/config.xml"));
NodeList nl=doc.getElementsByTagName("className");
Node classNode=null;
if(args.equals("color"))
{
classNode=nl.item(0).getFirstChild();
}
else if(args.equals("bag"))
{
classNode=nl.item(1).getFirstChild();
}
String cName="bridge."+classNode.getNodeValue();
Class<?> c=Class.forName(cName);
Object obj=c.newInstance();
return obj;
}
catch(Exception e)
{
e.printStackTrace();
return null;
}
}
}

程序的运行结果如图 3 所示。

图3 女士皮包选购的运行结果1

如果将 XML 配置文件按如下修改：

<?xml version="1.0" encoding="UTF-8"?>
<config>
<className>Red</className>
<className>Wallet</className>
</config>

则程序的运行结果如图 4 所示。

图4 女士皮包选购的运行结果2

桥接模式的应用场景

桥接模式通常适用于以下场景。

1. 当一个类存在两个独立变化的维度，且这两个维度都需要进行扩展时。
2. 当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时。
3. 当一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性时。

桥接模式模式的扩展

在软件开发中，有时桥接（Bridge）模式可与适配器模式联合使用。当桥接（Bridge）模式的实现化角色的接口与现有类的接口不一致时，可以在二者中间定义一个适配器将二者连接起来，其具体结构图如图 5 所示。

图5 桥接模式与适配器模式联用的结构图

9.装饰模式（装饰设计模式）

在现实生活中，常常需要对现有产品增加新的功能或美化其外观，如房子装修、相片加相框等。在软件开发过程中，有时想用一些现存的组件。这些组件可能只是完成了一些核心功能。但在不改变其结构的情况下，可以动态地扩展其功能。所有这些都可以釆用装饰模式来实现。

装饰模式的定义与特点

装饰（Decorator）模式的定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。

装饰（Decorator）模式的主要优点有：

• 采用装饰模式扩展对象的功能比采用继承方式更加灵活。
• 可以设计出多个不同的具体装饰类，创造出多个不同行为的组合。

其主要缺点是：装饰模式增加了许多子类，如果过度使用会使程序变得很复杂。

装饰模式的结构与实现

通常情况下，扩展一个类的功能会使用继承方式来实现。但继承具有静态特征，耦合度高，并且随着扩展功能的增多，子类会很膨胀。如果使用组合关系来创建一个包装对象（即装饰对象）来包裹真实对象，并在保持真实对象的类结构不变的前提下，为其提供额外的功能，这就是装饰模式的目标。下面来分析其基本结构和实现方法。

1. 模式的结构

装饰模式主要包含以下角色。

1. 抽象构件（Component）角色：定义一个抽象接口以规范准备接收附加责任的对象。
2. 具体构件（Concrete Component）角色：实现抽象构件，通过装饰角色为其添加一些职责。
3. 抽象装饰（Decorator）角色：继承抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。
4. 具体装饰（ConcreteDecorator）角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。

装饰模式的结构图如图 1 所示。

图1 装饰模式的结构图

2. 模式的实现

装饰模式的实现代码如下：

package decorator;
public class DecoratorPattern
{
public static void main(String[] args)
{
Component p=new ConcreteComponent();
p.operation();
System.out.println("---------------------------------");
Component d=new ConcreteDecorator(p);
 d.operation();
 }
 }
 //抽象构件角色
 interface  Component
 {
 public void operation();
 }
 //具体构件角色
 class ConcreteComponent implements Component
 {
 public ConcreteComponent()
 {
 System.out.println("创建具体构件角色");
 }
 public void operation()
 {
 System.out.println("调用具体构件角色的方法operation()");
 }
 }
 //抽象装饰角色
 class Decorator implements Component
 {
 private Component component;
 public Decorator(Component component)
 {
 this.component=component;
 }
 public void operation()
 {
 component.operation();
 }
 }
 //具体装饰角色
 class ConcreteDecorator extends Decorator
 {
 public ConcreteDecorator(Component component)
 {
 super(component);
 }
 public void operation()
 {
 super.operation();
 addedFunction();
 }
 public void addedFunction()
 {
 System.out.println("为具体构件角色增加额外的功能addedFunction()");
 }
 }

程序运行结果如下：

创建具体构件角色

调用具体构件角色的方法operation()

调用具体构件角色的方法operation()
为具体构件角色增加额外的功能addedFunction()

装饰模式的应用实例

【例1】用装饰模式实现游戏角色“莫莉卡·安斯兰”的变身。

分析：在《恶魔战士》中，游戏角色“莫莉卡·安斯兰”的原身是一个可爱少女，但当她变身时，会变成头顶及背部延伸出蝙蝠状飞翼的女妖，当然她还可以变为穿着漂亮外衣的少女。这些都可用装饰模式来实现，在本实例中的“莫莉卡”原身有 setImage(String t) 方法决定其显示方式，而其 变身“蝙蝠状女妖”和“着装少女”可以用 setChanger() 方法来改变其外观，原身与变身后的效果用 display() 方法来显示（点此下载其原身和变身后的图片），图 2 所示是其结构图。

图2 游戏角色“莫莉卡·安斯兰”的结构图

程序代码如下：

package decorator;
import java.awt.*;
import javax.swing.*;
public class MorriganAensland
{
public static void main(String[] args)
{
Morrigan m0=new original();
m0.display();
Morrigan m1=new Succubus(m0);
m1.display();
Morrigan m2=new Girl(m0);
m2.display();
}
}
//抽象构件角色：莫莉卡
interface  Morrigan
{
public void display();
}
//具体构件角色：原身
class original extends JFrame implements Morrigan
{
private static final long serialVersionUID = 1L;
private String t="Morrigan0.jpg";
public original()
{
super("《恶魔战士》中的莫莉卡·安斯兰");
}
public void setImage(String t)
{
this.t=t;
}
public void display()
{
this.setLayout(new FlowLayout());
JLabel l1=new JLabel(new ImageIcon("src/decorator/"+t));
this.add(l1);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
}
//抽象装饰角色：变形
class Changer implements Morrigan
{
Morrigan m;
public Changer(Morrigan m)
{
this.m=m;
}
public void display()
{
m.display();
}
}
//具体装饰角色：女妖
class Succubus extends Changer
{
public Succubus(Morrigan m)
{
super(m);
}
public void display()
{
setChanger();
super.display();
}
public void setChanger()
{
((original) super.m).setImage("Morrigan1.jpg");
}
}
//具体装饰角色：少女
class Girl extends Changer
{
public Girl(Morrigan m)
{
super(m);
}
public void display()
{
setChanger();
super.display();
}
public void setChanger()
{
((original) super.m).setImage("Morrigan2.jpg");
}
}

程序运行结果如图 3 所示。

图3 游戏角色“莫莉卡·安斯兰”的变身

装饰模式的应用场景

前面讲解了关于装饰模式的结构与特点，下面介绍其适用的应用场景，装饰模式通常在以下几种情况使用。

• 当需要给一个现有类添加附加职责，而又不能采用生成子类的方法进行扩充时。例如，该类被隐藏或者该类是终极类或者采用继承方式会产生大量的子类。
• 当需要通过对现有的一组基本功能进行排列组合而产生非常多的功能时，采用继承关系很难实现，而采用装饰模式却很好实现。
• 当对象的功能要求可以动态地添加，也可以再动态地撤销时。

装饰模式在 Java 语言中的最著名的应用莫过于 Java I/O 标准库的设计了。例如，InputStream 的子类 FilterInputStream，OutputStream 的子类 FilterOutputStream，Reader 的子类 BufferedReader 以及 FilterReader，还有 Writer 的子类 BufferedWriter、FilterWriter 以及 PrintWriter 等，它们都是抽象装饰类。

下面代码是为 FileReader 增加缓冲区而采用的装饰类 BufferedReader 的例子：

1. BufferedReader in=new BufferedReader(new FileReader(“filename.txtn));
2. String s=in.readLine();

装饰模式的扩展

装饰模式所包含的 4 个角色不是任何时候都要存在的，在有些应用环境下模式是可以简化的，如以下两种情况。

(1) 如果只有一个具体构件而没有抽象构件时，可以让抽象装饰继承具体构件，其结构图如图 4 所示。

图4 只有一个具体构件的装饰模式

(2) 如果只有一个具体装饰时，可以将抽象装饰和具体装饰合并，其结构图如图 5 所示。

图5 只有一个具体装饰的装饰模式

10.外观模式（Facade模式）

在现实生活中，常常存在办事较复杂的例子，如办房产证或注册一家公司，有时要同多个部门联系，这时要是有一个综合部门能解决一切手续问题就好了。

软件设计也是这样，当一个系统的功能越来越强，子系统会越来越多，客户对系统的访问也变得越来越复杂。这时如果系统内部发生改变，客户端也要跟着改变，这违背了“开闭原则”，也违背了“迪米特法则”，所以有必要为多个子系统提供一个统一的接口，从而降低系统的耦合度，这就是外观模式的目标。

图 1 给出了客户去当地房产局办理房产证过户要遇到的相关部门。

图1 办理房产证过户的相关部门

外观模式的定义与特点

外观（Facade）模式的定义：是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口，外部应用程序不用关心内部子系统的具体的细节，这样会大大降低应用程序的复杂度，提高了程序的可维护性。

外观（Facade）模式是“迪米特法则”的典型应用，它有以下主要优点。

1. 降低了子系统与客户端之间的耦合度，使得子系统的变化不会影响调用它的客户类。
2. 对客户屏蔽了子系统组件，减少了客户处理的对象数目，并使得子系统使用起来更加容易。
3. 降低了大型软件系统中的编译依赖性，简化了系统在不同平台之间的移植过程，因为编译一个子系统不会影响其他的子系统，也不会影响外观对象。

外观（Facade）模式的主要缺点如下。

1. 不能很好地限制客户使用子系统类。
2. 增加新的子系统可能需要修改外观类或客户端的源代码，违背了“开闭原则”。

外观模式的结构与实现

外观（Facade）模式的结构比较简单，主要是定义了一个高层接口。它包含了对各个子系统的引用，客户端可以通过它访问各个子系统的功能。现在来分析其基本结构和实现方法。

1. 模式的结构

外观（Facade）模式包含以下主要角色。

1. 外观（Facade）角色：为多个子系统对外提供一个共同的接口。
2. 子系统（Sub System）角色：实现系统的部分功能，客户可以通过外观角色访问它。
3. 客户（Client）角色：通过一个外观角色访问各个子系统的功能。

其结构图如图 2 所示。

图2 外观（Facade）模式的结构图

2. 模式的实现

外观模式的实现代码如下：

package facade;
public class FacadePattern
{
public static void main(String[] args)
{
Facade f=new Facade();
f.method();
}
}
 //外观角色
 class Facade
 {
 private SubSystem01 obj1=new SubSystem01();
 private SubSystem02 obj2=new SubSystem02();
 private SubSystem03 obj3=new SubSystem03();
 public void method()
 {
 obj1.method1();
 obj2.method2();
 obj3.method3();
 }
 }
 //子系统角色
 class SubSystem01
 {
 public  void method1()
 {
 System.out.println("子系统01的method1()被调用！");
 }
 }
 //子系统角色
 class SubSystem02
 {
 public  void method2()
 {
 System.out.println("子系统02的method2()被调用！");
 }
 }
 //子系统角色
 class SubSystem03
 {
 public  void method3()
 {
 System.out.println("子系统03的method3()被调用！");
 }
 }

程序运行结果如下：
子系统01的method1()被调用！
子系统02的method2()被调用！
子系统03的method3()被调用！

外观模式的应用实例

【例1】用“外观模式”设计一个婺源特产的选购界面。

分析：本实例的外观角色 WySpecialty 是 JPanel 的子类，它拥有 8 个子系统角色 Specialty1~Specialty8，它们是图标类（ImageIcon）的子类对象，用来保存该婺源特产的图标（点此下载要显示的婺源特产的图片）。

外观类（WySpecialty）用 JTree 组件来管理婺源特产的名称，并定义一个事件处理方法 valueClianged(TreeSelectionEvent e)，当用户从树中选择特产时，该特产的图标对象保存在标签（JLabd）对象中。

客户窗体对象用分割面板来实现，左边放外观角色的目录树，右边放显示所选特产图像的标签。其结构图如图 3 所示。

图3 婺源特产管理界面的结构图

程序代码如下：

package facade;
import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.tree.DefaultMutableTreeNode;
public class WySpecialtyFacade
{
public static void main(String[] args)
{
 JFrame f=new JFrame ("外观模式: 婺源特产选择测试");
 Container cp=f.getContentPane();
 WySpecialty wys=new WySpecialty();
 JScrollPane treeView=new JScrollPane(wys.tree);
 JScrollPane scrollpane=new JScrollPane(wys.label);
 JSplitPane splitpane=new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,true,treeView,scrollpane); //分割面版
 splitpane.setDividerLocation(230);     //设置splitpane的分隔线位置
 splitpane.setOneTouchExpandable(true); //设置splitpane可以展开或收起                       
 cp.add(splitpane);
 f.setSize(650,350);
 f.setVisible(true);
 f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 }
 }
 class WySpecialty extends JPanel implements TreeSelectionListener
 {
 private static final long serialVersionUID=1L;
 final JTree tree;
 JLabel label;
 private Specialty1 s1=new Specialty1();
 private Specialty2 s2=new Specialty2();
 private Specialty3 s3=new Specialty3();
 private Specialty4 s4=new Specialty4();
 private Specialty5 s5=new Specialty5();
 private Specialty6 s6=new Specialty6();
 private Specialty7 s7=new Specialty7();
 private Specialty8 s8=new Specialty8();
 WySpecialty(){
 DefaultMutableTreeNode top=new DefaultMutableTreeNode("婺源特产");
 DefaultMutableTreeNode node1=null,node2=null,tempNode=null;
 node1=new DefaultMutableTreeNode("婺源四大特产（红、绿、黑、白）");
 tempNode=new DefaultMutableTreeNode("婺源荷包红鲤鱼");
 node1.add(tempNode);
 tempNode=new DefaultMutableTreeNode("婺源绿茶");
 node1.add(tempNode);
 tempNode=new DefaultMutableTreeNode("婺源龙尾砚");
 node1.add(tempNode);
 tempNode=new DefaultMutableTreeNode("婺源江湾雪梨");
 node1.add(tempNode);
 top.add(node1);
 node2=new DefaultMutableTreeNode("婺源其它土特产");
 tempNode=new DefaultMutableTreeNode("婺源酒糟鱼");
 node2.add(tempNode);
 tempNode=new DefaultMutableTreeNode("婺源糟米子糕");
 node2.add(tempNode);
 tempNode=new DefaultMutableTreeNode("婺源清明果");
 node2.add(tempNode);
 tempNode=new DefaultMutableTreeNode("婺源油煎灯");
 node2.add(tempNode);
 top.add(node2);
 tree=new JTree(top);
 tree.addTreeSelectionListener(this);
 label=new JLabel();
 }
 public void valueChanged(TreeSelectionEvent e)
 {
 if(e.getSource()==tree)
 {
 DefaultMutableTreeNode node=(DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
 if(node==null) return;
 if(node.isLeaf())
 {
 Object object=node.getUserObject();
 String sele=object.toString();
 label.setText(sele);
 label.setHorizontalTextPosition(JLabel.CENTER);
 label.setVerticalTextPosition(JLabel.BOTTOM);
 sele=sele.substring(2,4);
 if(sele.equalsIgnoreCase("荷包")) label.setIcon(s1);
 else if(sele.equalsIgnoreCase("绿茶")) label.setIcon(s2);
 else if(sele.equalsIgnoreCase("龙尾")) label.setIcon(s3);
 else if(sele.equalsIgnoreCase("江湾")) label.setIcon(s4);
 else if(sele.equalsIgnoreCase("酒糟")) label.setIcon(s5);
 else if(sele.equalsIgnoreCase("糟米")) label.setIcon(s6);
 else if(sele.equalsIgnoreCase("清明")) label.setIcon(s7);
 else if(sele.equalsIgnoreCase("油煎")) label.setIcon(s8);
 label.setHorizontalAlignment(JLabel.CENTER);
 }
 }
 }
 }
 class Specialty1 extends ImageIcon
 {
 private static final long serialVersionUID=1L;
 Specialty1()
 {
 super("src/facade/WyImage/Specialty11.jpg");
 }
 }
 class Specialty2 extends ImageIcon
 {
 private static final long serialVersionUID=1L;
 Specialty2()
 {
 super("src/facade/WyImage/Specialty12.jpg");
 }
 }
 class Specialty3 extends ImageIcon
 {
 private static final long serialVersionUID=1L;
 Specialty3()
 {
 super("src/facade/WyImage/Specialty13.jpg");
 }
 }
 class Specialty4 extends ImageIcon
 {
 private static final long serialVersionUID=1L;
 Specialty4()
 {
 super("src/facade/WyImage/Specialty14.jpg");
 }
 }
 class Specialty5 extends ImageIcon
 {
 private static final long serialVersionUID=1L;
 Specialty5()
 {
 super("src/facade/WyImage/Specialty21.jpg");
 }
 }
 class Specialty6 extends ImageIcon
 {
 private static final long serialVersionUID=1L;
 Specialty6()
 {
 super("src/facade/WyImage/Specialty22.jpg");
 }
 }
 class Specialty7 extends ImageIcon
 {
 private static final long serialVersionUID=1L;
 Specialty7()
 {
 super("src/facade/WyImage/Specialty23.jpg");
 }
 }
 class Specialty8 extends ImageIcon
 {
 private static final long serialVersionUID=1L;
 Specialty8()
 {
 super("src/facade/WyImage/Specialty24.jpg");
 }
 }

程序运行结果如图 4 所示。

图4 婺源特产管理界面的运行结果

外观模式的应用场景

通常在以下情况下可以考虑使用外观模式。

1. 对分层结构系统构建时，使用外观模式定义子系统中每层的入口点可以简化子系统之间的依赖关系。
2. 当一个复杂系统的子系统很多时，外观模式可以为系统设计一个简单的接口供外界访问。
3. 当客户端与多个子系统之间存在很大的联系时，引入外观模式可将它们分离，从而提高子系统的独立性和可移植性。

外观模式的扩展

在外观模式中，当增加或移除子系统时需要修改外观类，这违背了“开闭原则”。如果引入抽象外观类，则在一定程度上解决了该问题，其结构图如图 5 所示。

图5 引入抽象外观类的外观模式的结构图

11.享元模式

在面向对象程序设计过程中，有时会面临要创建大量相同或相似对象实例的问题。创建那么多的对象将会耗费很多的系统资源，它是系统性能提高的一个瓶颈。例如，围棋和五子棋中的黑白棋子，图像中的坐标点或颜色，局域网中的路由器、交换机和集线器，教室里的桌子和凳子等。这些对象有很多相似的地方，如果能把它们相同的部分提取出来共享，则能节省大量的系统资源，这就是享元模式的产生背景。

享元模式的定义与特点

享元（Flyweight）模式的定义：运用共享技术来有効地支持大量细粒度对象的复用。它通过共享已经存在的又橡来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。

享元模式的主要优点是：相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。

其主要缺点是：

1. 为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。
2. 读取享元模式的外部状态会使得运行时间稍微变长。

享元模式的结构与实现

享元模式中存在以下两种状态：

1. 内部状态，即不会随着环境的改变而改变的可共享部分；
2. 外部状态，指随环境改变而改变的不可以共享的部分。享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。下面来分析其基本结构和实现方法。

1. 模式的结构

享元模式的主要角色有如下。

1. 抽象享元角色（Flyweight）:是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
2. 具体享元（Concrete Flyweight）角色：实现抽象享元角色中所规定的接口。
3. 非享元（Unsharable Flyweight)角色：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。
4. 享元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

图 1 是享元模式的结构图。图中的 UnsharedConcreteFlyweight 是与淳元角色，里面包含了非共享的外部状态信息 info；而 Flyweight 是抽象享元角色，里面包含了享元方法 operation(UnsharedConcreteFlyweight state)，非享元的外部状态以参数的形式通过该方法传入；ConcreteFlyweight 是具体享元角色，包含了关键字 key，它实现了抽象享元接口；FlyweightFactory 是享元工厂角色，它逝关键字 key 来管理具体享元；客户角色通过享元工厂获取具体享元，并访问具体享元的相关方法。

图1 享元模式的结构图

2. 模式的实现

享元模式的实现代码如下：

package flyweight;
import java.util.HashMap;
public class FlyweightPattern
{
public static void main(String[] args)
{
FlyweightFactory factory=new FlyweightFactory();
Flyweight f01=factory.getFlyweight("a");
Flyweight f02=factory.getFlyweight("a");
Flyweight f03=factory.getFlyweight("a");
Flyweight f11=factory.getFlyweight("b");
Flyweight f12=factory.getFlyweight("b");
f01.operation(new UnsharedConcreteFlyweight("第1次调用a。"));
f02.operation(new UnsharedConcreteFlyweight("第2次调用a。"));
f03.operation(new UnsharedConcreteFlyweight("第3次调用a。"));
f11.operation(new UnsharedConcreteFlyweight("第1次调用b。"));
f12.operation(new UnsharedConcreteFlyweight("第2次调用b。"));
}
}
//非享元角色
class UnsharedConcreteFlyweight
{
private String info;
UnsharedConcreteFlyweight(String info)
{
this.info=info;
}
public String getInfo()
{
return info;
}
public void setInfo(String info)
{
this.info=info;
}
}
//抽象享元角色
interface Flyweight
{
public void operation(UnsharedConcreteFlyweight state);
}
//具体享元角色
class ConcreteFlyweight implements Flyweight
{
private String key;
ConcreteFlyweight(String key)
{
this.key=key;
System.out.println("具体享元"+key+"被创建！");
}
public void operation(UnsharedConcreteFlyweight outState)
{
System.out.print("具体享元"+key+"被调用，");
System.out.println("非享元信息是:"+outState.getInfo());
}
}
//享元工厂角色
class FlyweightFactory
{
private HashMap<String, Flyweight> flyweights=new HashMap<String, Flyweight>();
public Flyweight getFlyweight(String key)
{
Flyweight flyweight=(Flyweight)flyweights.get(key);
if(flyweight!=null)
{
System.out.println("具体享元"+key+"已经存在，被成功获取！");
}
else
{
flyweight=new ConcreteFlyweight(key);
flyweights.put(key, flyweight);
}
return flyweight;
}
}

程序运行结果如下：
具体享元a被创建！
具体享元a已经存在，被成功获取！
具体享元a已经存在，被成功获取！
具体享元b被创建！
具体享元b已经存在，被成功获取！
具体享元a被调用，非享元信息是:第1次调用a。
具体享元a被调用，非享元信息是:第2次调用a。
具体享元a被调用，非享元信息是:第3次调用a。
具体享元b被调用，非享元信息是:第1次调用b。
具体享元b被调用，非享元信息是:第2次调用b。

享元模式的应用实例

【例1】享元模式在五子棋游戏中的应用。

分析：五子棋同围棋一样，包含多个“黑”或“白”颜色的棋子，所以用享元模式比较好。

本实例中的棋子（ChessPieces）类是抽象享元角色，它包含了一个落子的 DownPieces(Graphics g,Point pt) 方法；白子（WhitePieces）和黑子（BlackPieces）类是具体享元角色，它实现了落子方法；Point 是非享元角色，它指定了落子的位置；WeiqiFactory 是享元工厂角色，它通过 ArrayList 来管理棋子，并且提供了获取白子或者黑子的 getChessPieces(String type) 方法；客户类（Chessboard）利用 Graphics 组件在框架窗体中绘制一个棋盘，并实现 mouseClicked(MouseEvent e) 事件处理方法，该方法根据用户的选择从享元工厂中获取白子或者黑子并落在棋盘上。图 2 所示是其结构图。

图2 五子棋游戏的结构图

程序代码如下：

package flyweight;
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import javax.swing.*;
public class WzqGame
{
public static void main(String[] args)
{
new Chessboard();
}
}
//棋盘
class Chessboard extends MouseAdapter
{
WeiqiFactory wf;
JFrame f;
Graphics g;
JRadioButton wz;
JRadioButton bz;
private final int x=50;
private final int y=50;
private final int w=40;    //小方格宽度和高度
private final int rw=400;    //棋盘宽度和高度
Chessboard()
{
wf=new WeiqiFactory();
f=new JFrame("享元模式在五子棋游戏中的应用");
f.setBounds(100,100,500,550);
f.setVisible(true);
f.setResizable(false);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel SouthJP=new JPanel();
f.add("South",SouthJP);
wz=new JRadioButton("白子");
bz=new JRadioButton("黑子",true);
ButtonGroup group=new ButtonGroup();
group.add(wz);
group.add(bz);
SouthJP.add(wz);
SouthJP.add(bz);
JPanel CenterJP=new JPanel();
CenterJP.setLayout(null);
CenterJP.setSize(500, 500);
CenterJP.addMouseListener(this);
f.add("Center",CenterJP);
try
{
Thread.sleep(500);
}
catch(InterruptedException e)
{
e.printStackTrace();
}
g=CenterJP.getGraphics();
g.setColor(Color.BLUE);
g.drawRect(x, y, rw, rw);
for(int i=1;i<10;i++)
{
//绘制第i条竖直线
g.drawLine(x+(i*w),y,x+(i*w),y+rw);
//绘制第i条水平线
g.drawLine(x,y+(i*w),x+rw,y+(i*w));
}
}
public void mouseClicked(MouseEvent e)
{
Point pt=new Point(e.getX()-15,e.getY()-15);
if(wz.isSelected())
{
ChessPieces c1=wf.getChessPieces("w");
c1.DownPieces(g,pt);
}
else if(bz.isSelected())
{
ChessPieces c2=wf.getChessPieces("b");
c2.DownPieces(g,pt);
}
}
}
//抽象享元角色：棋子
interface ChessPieces
{
public void DownPieces(Graphics g,Point pt);    //下子
}
//具体享元角色：白子
class WhitePieces implements ChessPieces
{
public void DownPieces(Graphics g,Point pt)
{
g.setColor(Color.WHITE);
g.fillOval(pt.x,pt.y,30,30);
}
}
//具体享元角色：黑子
class BlackPieces implements ChessPieces
{
public void DownPieces(Graphics g,Point pt)
{
g.setColor(Color.BLACK);
g.fillOval(pt.x,pt.y,30,30);
}
}
//享元工厂角色
class WeiqiFactory
{
private ArrayList<ChessPieces> qz;
public WeiqiFactory()
{
qz=new ArrayList<ChessPieces>();
ChessPieces w=new WhitePieces();
qz.add(w);
ChessPieces b=new BlackPieces();
qz.add(b);
}
public ChessPieces getChessPieces(String type)
{
if(type.equalsIgnoreCase("w"))
{
return (ChessPieces)qz.get(0);
}
else if(type.equalsIgnoreCase("b"))
{
return (ChessPieces)qz.get(1);
}
else
{
return null;
}
}
}

程序运行结果如图 3 所示。

图3 五子棋游戏的运行结果

享元模式的应用场景

前面分析了享元模式的结构与特点，下面分析它适用的应用场景。享元模式是通过减少内存中对象的数量来节省内存空间的，所以以下几种情形适合采用享元模式。

1. 系统中存在大量相同或相似的对象，这些对象耗费大量的内存资源。
2. 大部分的对象可以按照内部状态进行分组，且可将不同部分外部化，这样每一个组只需保存一个内部状态。
3. 由于享元模式需要额外维护一个保存享元的数据结构，所以应当在有足够多的享元实例时才值得使用享元模式。

享元模式的扩展

在前面介绍的享元模式中，其结构图通常包含可以共享的部分和不可以共享的部分。在实际使用过程中，有时候会稍加改变，即存在两种特殊的享元模式：单纯享元模式和复合享元模式，下面分别对它们进行简单介绍。

(1) 单纯享元模式，这种享元模式中的所有的具体享元类都是可以共享的，不存在非共享的具体享元类，其结构图如图 4 所示。

图4 单纯享元模式的结构图

(2) 复合享元模式，这种享元模式中的有些享元对象是由一些单纯享元对象组合而成的，它们就是复合享元对象。虽然复合享元对象本身不能共享，但它们可以分解成单纯享元对象再被共享，其结构图如图 5 所示。

图5 复合享元模式的结构图

12.组合模式

在现实生活中，存在很多“部分-整体”的关系，例如，大学中的部门与学院、总公司中的部门与分公司、学习用品中的书与书包、生活用品中的衣月艮与衣柜以及厨房中的锅碗瓢盆等。在软件开发中也是这样，例如，文件系统中的文件与文件夹、窗体程序中的简单控件与容器控件等。对这些简单对象与复合对象的处理，如果用组合模式来实现会很方便。

组合模式的定义与特点

组合（Composite）模式的定义：有时又叫作部分-整体模式，它是一种将对象组合成树状的层次结构的模式，用来表示“部分-整体”的关系，使用户对单个对象和组合对象具有一致的访问性。

组合模式的主要优点有：

1. 组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码；
2. 更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足“开闭原则”；

其主要缺点是：

1. 设计较复杂，客户端需要花更多时间理清类之间的层次关系；
2. 不容易限制容器中的构件；
3. 不容易用继承的方法来增加构件的新功能；

组合模式的结构与实现

组合模式的结构不是很复杂，下面对它的结构和实现进行分析。

1. 模式的结构

组合模式包含以下主要角色。

1. 抽象构件（Component）角色：它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口；在安全式的组合模式中不声明访问和管理子类的接口，管理工作由树枝构件完成。
2. 树叶构件（Leaf）角色：是组合中的叶节点对象，它没有子节点，用于实现抽象构件角色中 声明的公共接口。
3. 树枝构件（Composite）角色：是组合中的分支节点对象，它有子节点。它实现了抽象构件角色中声明的接口，它的主要作用是存储和管理子部件，通常包含 Add()、Remove()、GetChild() 等方法。

组合模式分为透明式的组合模式和安全式的组合模式。

(1) 透明方式：在该方式中，由于抽象构件声明了所有子类中的全部方法，所以客户端无须区别树叶对象和树枝对象，对客户端来说是透明的。但其缺点是：树叶构件本来没有 Add()、Remove() 及 GetChild() 方法，却要实现它们（空实现或抛异常），这样会带来一些安全性问题。其结构图如图 1 所示。

图1 透明式的组合模式的结构图

(2) 安全方式：在该方式中，将管理子构件的方法移到树枝构件中，抽象构件和树叶构件没有对子对象的管理方法，这样就避免了上一种方式的安全性问题，但由于叶子和分支有不同的接口，客户端在调用时要知道树叶对象和树枝对象的存在，所以失去了透明性。其结构图如图 2 所示。

图2 安全式的组合模式的结构图

2. 模式的实现

假如要访问集合 c0={leaf1,{leaf2,leaf3}} 中的元素，其对应的树状图如图 3 所示。

图3 集合c0的树状图

下面给出透明式的组合模式的实现代码，与安全式的组合模式的实现代码类似，只要对其做简单修改就可以了。

 package composite;
 import java.util.ArrayList;
 public class CompositePattern
 {
 public static void main(String[] args)
 {
 Component c0=new Composite();
 Component c1=new Composite();
 Component leaf1=new Leaf("1");
 Component leaf2=new Leaf("2");
 Component leaf3=new Leaf("3");
 c0.add(leaf1);
 c0.add(c1);
 c1.add(leaf2);
 c1.add(leaf3);
 c0.operation();
 }
 }
 //抽象构件
 interface Component
 {
 public void add(Component c);
 public void remove(Component c);
 public Component getChild(int i);
 public void operation();
 }
 //树叶构件
 class Leaf implements Component
 {
 private String name;
 public Leaf(String name)
 {
 this.name=name;
 }
 public void add(Component c){ }
 public void remove(Component c){ }
 public Component getChild(int i)
 {
 return null;
 }
 public void operation()
 {
 System.out.println("树叶"+name+"：被访问！");
 }
 }
 //树枝构件
 class Composite implements Component
 {
 private ArrayList<Component> children=new ArrayList<Component>();
 public void add(Component c)
 {
 children.add(c);
 }
 public void remove(Component c)
 {
 children.remove(c);
 }
 public Component getChild(int i)
 {
 return children.get(i);
 }
 public void operation()
 {
 for(Object obj:children)
 {
 ((Component)obj).operation();
 }
 }
 }