设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。 设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理地运用设计模式可以完美地解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式都描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是设计模式能被广泛应用的原因。 ## 一、创建型设计模式 ### 1.1 单例模式（Singleton Pattern） **模式定义：** 一个类只有一个实例，且该类能自行创建这个实例，并提供一个访问它的全局访问点。 单例模式有 3 个特点： 1. 单例类只有一个实例对象； 2. 该单例对象必须由单例类自行创建； 3. 单例类对外提供一个访问该单例的全局访问点。 **模式优点：** - 单例模式可以保证内存里只有一个实例，减少了内存的开销。 - 可以避免对资源的多重占用。 - 单例模式设置全局访问点，可以优化和共享资源的访问。 **模式缺点：** - 单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。 - 在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。 - 单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。 **应用场景：** - 需要频繁创建的一些类，使用单例可以降低系统的内存压力，减少 GC。 - 某类只要求生成一个对象的时候，如一个班中的班长、每个人的身份证号等。 - 某些类创建实例时占用资源较多，或实例化耗时较长，且经常使用。 - 某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。 - 频繁访问数据库或文件的对象。 - 对于一些控制硬件级别的操作，或者从系统上来讲应当是单一控制逻辑的操作，如果有多个实例，则系统会完全乱套。 - 当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。 **代码实现：** Singleton 模式通常有两种实现形式。 第 1 种：懒汉式单例 该模式的特点是类加载时没有生成单例，只有当第一次调用 getlnstance 方法时才去创建这个单例。代码如下： ```java public class LazySingleton { // volatile 关键字保证了：1. instance 实例对所有线程都是可见的； 2. 禁止了 instance 操作指令冲排序。 private static volatile LazySingleton instance = null; // private 避免类在外部被实例化 private LazySingleton() {} public static synchronized LazySingleton getInstance() { // 第一次校验，防止不必要的同步 if(instance == null) { // synchronized 关键字加锁，保证每次只有一个线程执行对象初始化操作 synchronized (LazySingleton.class) { // 第二次校验，进行判空，如果为空则执行初始化 if(instance == null) { instance = new LazySingleton(); } } } return instance; } } ``` > 注意： 如果编写的是多线程程序，则不要删除上例代码中的关键字 volatile 和 synchronized，否则将存在线程非安全的问题。如果不删除这两个关键字就能保证线程安全，但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。 第 2 种：饿汉式单例 该模式的特点是类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了。代码如下： ```java public class HungrySingleton { private static final HungrySingleton instance = new HungrySingleton(); private HungrySingleton() {} public static HungrySingleton getInstance() { return instance; } } ``` > 饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的，可以直接用于多线程而不会出现问题。 ### 1.2 建造者模式（Builder Pattern） **模式定义：** 将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。 **模式优点：** - 封装性好，构建和表示分离。 - 扩展性好，各个具体的建造者相互独立，有利于系统的解耦。 - 客户端不必知道产品内部组成的细节，建造者可以对创建过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险。 **模式缺点：** - 产品的组成部分必须相同，这限制了其使用范围。 - 如果产品的内部变化复杂，如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大。 **应用场景：** - 相同的方法，不同的执行顺序，产生不同的结果。 - 多个部件或零件，都可以装配到一个对象中，但是产生的结果又不相同。 - 产品类非常复杂，或者产品类中不同的调用顺序产生不同的作用。 - 初始化一个对象特别复杂，参数多，而且很多参数都具有默认值。 **代码实现：** (1) 产品角色：包含多个组成部件的复杂对象。 ```java 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) 抽象建造者：包含创建产品各个子部件的抽象方法。 ```java 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) 具体建造者：实现了抽象建造者接口。 ```java public class ConcreteBuilder extends Builder { public void buildPartA() { product.setPartA("建造 PartA"); } public void buildPartB() { product.setPartA("建造 PartB"); } public void buildPartC() { product.setPartA("建造 PartC"); } } ``` (4) 指挥者：调用建造者中的方法完成复杂对象的创建。 ```java 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) 客户类。 ```java 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.3 原型模式（Prototype Pattern） **模式定义：** 用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。 **模式优点：** - Java 自带的原型模式基于内存二进制流的复制，在性能上比直接 new 一个对象更加优良。 - 可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份，并将其状态保存起来，简化了创建对象的过程，以便在需要的时候使用（例如恢复到历史某一状态），可辅助实现撤销操作。 **模式缺点：** - 需要为每一个类都配置一个 clone 方法，clone 方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违背了开闭原则。 - 当实现深克隆时，需要编写较为复杂的代码，而且当对象之间存在多重嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来会比较麻烦。因此，深克隆、浅克隆需要运用得当。 **应用场景：** - 对象之间相同或相似，即只是个别的几个属性不同的时候。 - 创建对象成本较大，例如初始化时间长，占用CPU太多，或者占用网络资源太多等，需要优化资源。 - 创建一个对象需要繁琐的数据准备或访问权限等，需要提高性能或者提高安全性。 - 系统中大量使用该类对象，且各个调用者都需要给它的属性重新赋值。 **代码实现：** 原型模式的克隆分为浅克隆和深克隆。 - 浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。 - 深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。 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)); } } ``` ### 1.4 简单工厂模式（Simple Factory Pattern） **模式定义：** 简单来说，简单工厂模式有一个具体的工厂类，可以生成多个不同的产品。 **模式优点：** - 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。 - 客户端无需知道所创建具体产品的类名，只需知道参数即可。 - 也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。 **模式缺点：** - 简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，一旦异常，整个系统将受影响。且工厂类代码会非常臃肿，违背高聚合原则。 - 使用简单工厂模式会增加系统中类的个数（引入新的工厂类），增加系统的复杂度和理解难度。 - 系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂。 - 简单工厂模式使用了 static 工厂方法，造成工厂角色无法形成基于继承的等级结构。 **应用场景：** - 对于产品种类相对较少的情况，考虑使用简单工厂模式。使用简单工厂模式的客户端只需要传入工厂类的参数，不需要关心如何创建对象的逻辑，可以很方便地创建所需产品。 **代码实现：** ```java public class Client { public static void main(String[] args) { } // 抽象产品 public interface Product { void show(); } // 具体产品：ProductA static class ConcreteProduct1 implements Product { public void show() { System.out.println("具体产品1显示..."); } } // 具体产品：ProductB static 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; } } } ``` ### 1.5 工厂模式（Factory Pattern） **模式定义：** 定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。 **模式优点：** - 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。 - 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。 - 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。 **模式缺点：** - 类的个数容易过多，增加复杂度。 - 增加了系统的抽象性和理解难度。 - 抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。 **应用场景：** - 客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。 - 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。 - 客户不关心创建产品的细节，只关心产品的品牌 **代码实现：** ```java 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(); } } ``` ```java 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; } } } ``` ### 1.6 抽象工厂模式（Abstract Factory Pattern） **模式定义：** 提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。 使用抽象工厂模式一般要满足以下条件： - 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。 - 系统一次只可能消费其中某一族产品，即同族的产品一起使用。 **模式优点：** - 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。 - 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。 - 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。 - 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。 - 当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。 - 抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。 **模式缺点：** - 当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。 **应用场景：** - 当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。 - 系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。 - 系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。 **代码实现：** (1) 抽象工厂：提供了产品的生成方法。 ```java interface AbstractFactory { public Product1 newProduct1(); public Product2 newProduct2(); } ``` (2) 具体工厂：实现了产品的生成方法。 ```java class ConcreteFactory1 implements AbstractFactory { public Product1 newProduct1() { System.out.println("具体工厂 1 生成-->具体产品 11..."); return new ConcreteProduct11(); } public Product2 newProduct2() { System.out.println("具体工厂 1 生成-->具体产品 21..."); return new ConcreteProduct21(); } } ``` ## 二、结构型设计模式 ### 2.1 适配器模式（Adapter Pattern） **模式定义：** 将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。适配器模式分为类结构型模式和对象结构型模式两种，前者类之间的耦合度比后者高，且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少些。 **模式优点：** - 客户端通过适配器可以透明地调用目标接口。 - 复用了现存的类，程序员不需要修改原有代码而重用现有的适配者类。 - 将目标类和适配者类解耦，解决了目标类和适配者类接口不一致的问题。 **模式缺点：** - 对类适配器来说，更换适配器的实现过程比较复杂。 **应用场景：** - 以前开发的系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致。 - 使用第三方提供的组件，但组件接口定义和自己要求的接口定义不同。 **代码实现：** (1) 类适配器模式的代码如下。 ```java 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)对象适配器模式的代码如下。 ```java 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(); } } ``` ### 2.2 组合模式（Composite Pattern） **模式定义：** 有时又叫作部分-整体模式，它是一种将对象组合成树状的层次结构的模式，用来表示“部分-整体”的关系，使用户对单个对象和组合对象具有一致的访问性。 **模式优点：** - 组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码。 - 更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足“开闭原则”。 **模式缺点：** - 设计较复杂，客户端需要花更多时间理清类之间的层次关系。 - 不容易限制容器中的构件。 - 不容易用继承的方法来增加构件的新功能。 **应用场景：** - 在需要表示一个对象整体与部分的层次结构的场合。 - 要求对用户隐藏组合对象与单个对象的不同，用户可以用统一的接口使用组合结构中的所有对象的场合。 **代码实现：** ```java 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(); } } } ``` ### 2.3 装饰器模式（Decorator Pattern） **模式定义：** 在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式。 **模式优点：** - 采用装饰模式扩展对象的功能比采用继承方式更加灵活。 - 可以设计出多个不同的具体装饰类，创造出多个不同行为的组合。 **模式缺点：** - 装饰模式增加了许多子类，如果过度使用会使程序变得很复杂。 **应用场景：** - 当需要给一个现有类添加附加职责，而又不能采用生成子类的方法进行扩充时。例如，该类被隐藏或者该类是终极类或者采用继承方式会产生大量的子类。 - 当需要通过对现有的一组基本功能进行排列组合而产生非常多的功能时，采用继承关系很难实现，而采用装饰模式却很好实现。 - 当对象的功能要求可以动态地添加，也可以再动态地撤销时。 **代码实现：** ```java 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()"); } } ``` ### 2.4 外观模式（Facade Pattern） **模式定义：** 一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口，外部应用程序不用关心内部子系统的具体的细节，这样会大大降低应用程序的复杂度，提高了程序的可维护性。 **模式优点：** - 降低了子系统与客户端之间的耦合度，使得子系统的变化不会影响调用它的客户类。 - 对客户屏蔽了子系统组件，减少了客户处理的对象数目，并使得子系统使用起来更加容易。 - 降低了大型软件系统中的编译依赖性，简化了系统在不同平台之间的移植过程，因为编译一个子系统不会影响其他的子系统，也不会影响外观对象。 **模式缺点：** - 不能很好地限制客户使用子系统类。 - 增加新的子系统可能需要修改外观类或客户端的源代码，违背了“开闭原则”。 **应用场景：** - 对分层结构系统构建时，使用外观模式定义子系统中每层的入口点可以简化子系统之间的依赖关系。 - 当一个复杂系统的子系统很多时，外观模式可以为系统设计一个简单的接口供外界访问。 - 当客户端与多个子系统之间存在很大的联系时，引入外观模式可将它们分离，从而提高子系统的独立性和可移植性。 **代码实现：** ```java 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()被调用！"); } } ``` ### 2.5 桥接模式（Bridge Pattern） **模式定义：** 将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。 **模式优点：** - 由于抽象与实现分离，所以扩展能力强； - 其实现细节对客户透明。 **模式缺点：** - 由于聚合关系建立在抽象层，要求开发者针对抽象化进行设计与编程，这增加了系统的理解与设计难度。 **应用场景：** - 当一个类存在两个独立变化的维度，且这两个维度都需要进行扩展时。 - 当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时。 - 当一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性时。 **代码实现：** ```java package bridge; public class BridgeTest { public static void main(String[] args) { Implementor imple=new ConcreteImplementorA(); Abstraction abs=new RefinedAbstraction(imple); abs.Operation(); } } // 实现化角色 interface Implementor { public void OperationImpl(); } // 具体实现化角色 class ConcreteImplementorA implements Implementor { public void OperationImpl() { System.out.println("具体实现化(Concrete Implementor)角色被访问" ); } } // 抽象化角色 abstract class Abstraction { protected Implementor imple; protected Abstraction(Implementor imple) { this.imple=imple; } public abstract void Operation(); } // 扩展抽象化角色 class RefinedAbstraction extends Abstraction { protected RefinedAbstraction(Implementor imple) { super(imple); } public void Operation() { System.out.println("扩展抽象化(Refined Abstraction)角色被访问" ); imple.OperationImpl(); } } ``` ### 2.6 享元模式（Flyweight Pattern） **模式定义：** 运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。 **模式优点：** - 相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。 **模式缺点：** - 为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。 - 读取享元模式的外部状态会使得运行时间稍微变长。 **应用场景：** - 系统中存在大量相同或相似的对象，这些对象耗费大量的内存资源。 - 大部分的对象可以按照内部状态进行分组，且可将不同部分外部化，这样每一个组只需保存一个内部状态。 - 由于享元模式需要额外维护一个保存享元的数据结构，所以应当在有足够多的享元实例时才值得使用享元模式。 **代码实现：** ```java 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; } } } ``` ### 2.7 代理模式（Proxy Pattern） **模式定义：** 由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。 **模式优点：** - 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用。 - 代理对象可以扩展目标对象的功能。 - 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度，增加了程序的可扩展性。 **模式缺点：** - 代理模式会造成系统设计中类的数量增加。 - 在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢。 - 增加了系统的复杂度。 **应用场景：** - 远程代理，这种方式通常是为了隐藏目标对象存在于不同地址空间的事实，方便客户端访问。例如，用户申请某些网盘空间时，会在用户的文件系统中建立一个虚拟的硬盘，用户访问虚拟硬盘时实际访问的是网盘空间。 - 虚拟代理，这种方式通常用于要创建的目标对象开销很大时。例如，下载一幅很大的图像需要很长时间，因某种计算比较复杂而短时间无法完成，这时可以先用小比例的虚拟代理替换真实的对象，消除用户对服务器慢的感觉。 - 安全代理，这种方式通常用于控制不同种类客户对真实对象的访问权限。 - 智能指引，主要用于调用目标对象时，代理附加一些额外的处理功能。例如，增加计算真实对象的引用次数的功能，这样当该对象没有被引用时，就可以自动释放它。 - 延迟加载，指为了提高系统的性能，延迟对目标的加载。例如，Hibernate 中就存在属性的延迟加载和关联表的延时加载。 **代码实现：** ```java 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("访问真实主题之后的后续处理。"); } } ``` ## 三、行为型设计模式 ### 3.1 模板模式（Template Pattern） **模式定义：** 定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。它是一种类行为型模式。 **模式优点：** - 它封装了不变部分，扩展可变部分。它把认为是不变部分的算法封装到父类中实现，而把可变部分算法由子类继承实现，便于子类继续扩展。 - 它在父类中提取了公共的部分代码，便于代码复用。 - 部分方法是由子类实现的，因此子类可以通过扩展方式增加相应的功能，符合开闭原则。 **模式缺点：** - 对每个不同的实现都需要定义一个子类，这会导致类的个数增加，系统更加庞大，设计也更加抽象。 - 父类中的抽象方法由子类实现，子类执行的结果会影响父类的结果，这导致一种反向的控制结构，它提高了代码阅读的难度。 **应用场景：** - 算法的整体步骤很固定，但其中个别部分易变时，这时候可以使用模板方法模式，将容易变的部分抽象出来，供子类实现。 - 当多个子类存在公共的行为时，可以将其提取出来并集中到一个公共父类中以避免代码重复。首先，要识别现有代码中的不同之处，并且将不同之处分离为新的操作。最后，用一个调用这些新的操作的模板方法来替换这些不同的代码。 - 当需要控制子类的扩展时，模板方法只在特定点调用钩子操作，这样就只允许在这些点进行扩展。 **代码实现：** ```java package templateMethod; public class TemplateMethodPattern { public static void main(String[] args) { AbstractClass tm=new ConcreteClass(); tm.TemplateMethod(); } } // 抽象类 abstract class AbstractClass { public void TemplateMethod() { // 模板方法 SpecificMethod(); abstractMethod1(); abstractMethod2(); } public void SpecificMethod() { // 具体方法 System.out.println("抽象类中的具体方法被调用..."); } public abstract void abstractMethod1(); // 抽象方法1 public abstract void abstractMethod2(); // 抽象方法2 } // 具体子类 class ConcreteClass extends AbstractClass { public void abstractMethod1() { System.out.println("抽象方法1的实现被调用..."); } public void abstractMethod2() { System.out.println("抽象方法2的实现被调用..."); } } ``` ### 3.2 解释器模式（Interpreter Pattern） **模式定义：** 给分析对象定义一个语言，并定义该语言的文法表示，再设计一个解析器来解释语言中的句子。也就是说，用编译语言的方式来分析应用中的实例。这种模式实现了文法表达式处理的接口，该接口解释一个特定的上下文。 **模式优点：** - 扩展性好。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法。 - 容易实现。在语法树中的每个表达式节点类都是相似的，所以实现其文法较为容易。 **模式缺点：** - 执行效率较低。解释器模式中通常使用大量的循环和递归调用，当要解释的句子较复杂时，其运行速度很慢，且代码的调试过程也比较麻烦。 - 会引起类膨胀。解释器模式中的每条规则至少需要定义一个类，当包含的文法规则很多时，类的个数将急剧增加，导致系统难以管理与维护。 - 可应用的场景比较少。在软件开发中，需要定义语言文法的应用实例非常少，所以这种模式很少被使用到。 **应用场景：** - 当语言的文法较为简单，且执行效率不是关键问题时。 - 当问题重复出现，且可以用一种简单的语言来进行表达时。 - 当一个语言需要解释执行，并且语言中的句子可以表示为一个抽象语法树的时候，如 XML 文档解释。 **代码实现：** 解释器模式实现的关键是定义文法规则、设计终结符类与非终结符类、画出结构图，必要时构建语法树，其代码结构如下： ```java // 抽象表达式类 interface AbstractExpression { public Object interpret(String info); // 解释方法 } // 终结符表达式类 class TerminalExpression implements AbstractExpression { public Object interpret(String info) { // 对终结符表达式的处理 } } // 非终结符表达式类 class NonterminalExpression implements AbstractExpression { private AbstractExpression exp1; private AbstractExpression exp2; public Object interpret(String info) { // 非对终结符表达式的处理 } } // 环境类 class Context { private AbstractExpression exp; public Context() { // 数据初始化 } public void operation(String info) { // 调用相关表达式类的解释方法 } } ``` ### 3.3 策略模式（Strategy Pattern） **模式定义：** 该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。 **模式优点：** - 多重条件语句不易维护，而使用策略模式可以避免使用多重条件语句。 - 策略模式提供了一系列的可供重用的算法族，恰当使用继承可以把算法族的公共代码转移到父类里面，从而避免重复的代码。 - 策略模式可以提供相同行为的不同实现，客户可以根据不同时间或空间要求选择不同的。 - 策略模式提供了对开闭原则的完美支持，可以在不修改原代码的情况下，灵活增加新算法。 - 策略模式把算法的使用放到环境类中，而算法的实现移到具体策略类中，实现了二者的分离。 **模式缺点：** - 客户端必须理解所有策略算法的区别，以便适时选择恰当的算法类。 - 策略模式造成很多的策略类。 **应用场景：** - 一个系统需要动态地在几种算法中选择一种时，可将每个算法封装到策略类中。 - 一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现，可将每个条件分支移入它们各自的策略类中以代替这些条件语句。 - 系统中各算法彼此完全独立，且要求对客户隐藏具体算法的实现细节时。 - 系统要求使用算法的客户不应该知道其操作的数据时，可使用策略模式来隐藏与算法相关的数据结构。 - 多个类只区别在表现行为不同，可以使用策略模式，在运行时动态选择具体要执行的行为。 **代码实现：** ```java package strategy; public class StrategyPattern { public static void main(String[] args) { Context c=new Context(); Strategy s=new ConcreteStrategyA(); c.setStrategy(s); c.strategyMethod(); System.out.println("-----------------"); s=new ConcreteStrategyB(); c.setStrategy(s); c.strategyMethod(); } } // 抽象策略类 interface Strategy { public void strategyMethod(); // 策略方法 } // 具体策略类A class ConcreteStrategyA implements Strategy { public void strategyMethod() { System.out.println("具体策略A的策略方法被访问！"); } } // 具体策略类B class ConcreteStrategyB implements Strategy { public void strategyMethod() { System.out.println("具体策略B的策略方法被访问！"); } } // 环境类 class Context { private Strategy strategy; public Strategy getStrategy() { return strategy; } public void setStrategy(Strategy strategy) { this.strategy=strategy; } public void strategyMethod() { strategy.strategyMethod(); } } ``` ### 3.4 状态模式（State Pattern） **模式定义：** 对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。 **模式优点：** - 状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分割开来，满足“单一职责原则”。 - 减少对象间的相互依赖。将不同的状态引入独立的对象中会使得状态转换变得更加明确，且减少对象间的相互依赖。 - 有利于程序的扩展。通过定义新的子类很容易地增加新的状态和转换。 **模式缺点：** - 状态模式的使用必然会增加系统的类与对象的个数。 - 状态模式的结构与实现都较为复杂，如果使用不当会导致程序结构和代码的混乱。 **应用场景：** - 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。 - 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。 **代码实现：** ```java package state; public class StatePatternClient { public static void main(String[] args) { Context context=new Context(); // 创建环境 context.Handle(); // 处理请求 context.Handle(); context.Handle(); context.Handle(); } } // 环境类 class Context { private State state; // 定义环境类的初始状态 public Context() { this.state=new ConcreteStateA(); } // 设置新状态 public void setState(State state) { this.state=state; } // 读取状态 public State getState() { return(state); } // 对请求做处理 public void Handle() { state.Handle(this); } } // 抽象状态类 abstract class State { public abstract void Handle(Context context); } // 具体状态A类 class ConcreteStateA extends State { public void Handle(Context context) { System.out.println("当前状态是 A."); context.setState(new ConcreteStateB()); } } // 具体状态B类 class ConcreteStateB extends State { public void Handle(Context context) { System.out.println("当前状态是 B."); context.setState(new ConcreteStateA()); } } ``` ### 3.5 观察者模式（Observer Pattern） **模式定义：** 多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式。 **模式优点：** - 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。 - 目标与观察者之间建立了一套触发机制。 **模式缺点：** - 目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。 - 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。 **应用场景：** - 对象间存在一对多关系，一个对象的状态发生改变会影响其他对象。 - 当一个抽象模型有两个方面，其中一个方面依赖于另一方面时，可将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。 **代码实现：** ```java package 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(); // 反应 } // 具体观察者1 class ConcreteObserver1 implements Observer { public void response() { System.out.println("具体观察者1作出反应！"); } } // 具体观察者1 class ConcreteObserver2 implements Observer { public void response() { System.out.println("具体观察者2作出反应！"); } } ``` ### 3.6 备忘录模式（Memento Pattern） **模式定义：** 在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后当需要时能将该对象恢复到原先保存的状态。该模式又叫快照模式。 **模式优点：** - 提供了一种可以恢复状态的机制。当用户需要时能够比较方便地将数据恢复到某个历史的状态。 - 实现了内部状态的封装。除了创建它的发起人之外，其他对象都不能够访问这些状态信息。 - 简化了发起人类。发起人不需要管理和保存其内部状态的各个备份，所有状态信息都保存在备忘录中，并由管理者进行管理，这符合单一职责原则。 **模式缺点：** - 资源消耗大。如果要保存的内部状态信息过多或者特别频繁，将会占用比较大的内存资源。 **应用场景：** - 需要保存与恢复数据的场景，如玩游戏时的中间结果的存档功能。 - 需要提供一个可回滚操作的场景，如 Word、记事本、Photoshop，Eclipse 等软件在编辑时按 Ctrl+Z 组合键，还有数据库中事务操作。 **代码实现：** ```java package memento; public class MementoPattern { public static void main(String[] args) { Originator or=new Originator(); Caretaker cr=new Caretaker(); or.setState("S0"); System.out.println("初始状态:"+or.getState()); cr.setMemento(or.createMemento()); // 保存状态 or.setState("S1"); System.out.println("新的状态:"+or.getState()); or.restoreMemento(cr.getMemento()); // 恢复状态 System.out.println("恢复状态:"+or.getState()); } } // 备忘录 class Memento { private String state; public Memento(String state) { this.state=state; } public void setState(String state) { this.state=state; } public String getState() { return state; } } // 发起人 class Originator { private String state; public void setState(String state) { this.state=state; } public String getState() { return state; } public Memento createMemento() { return new Memento(state); } public void restoreMemento(Memento m) { this.setState(m.getState()); } } // 管理者 class Caretaker { private Memento memento; public void setMemento(Memento m) { memento=m; } public Memento getMemento() { return memento; } } ``` ### 3.7 中介者模式（Mediator Pattern） **模式定义：** 定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用。 **模式优点：** - 降低了对象之间的耦合性，使得对象易于独立地被复用。 - 将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。 **模式缺点：** - 当同事类太多时，中介者的职责将很大，它会变得复杂而庞大，以至于系统难以维护。 **应用场景：** - 当对象之间存在复杂的网状结构关系而导致依赖关系混乱且难以复用时。 - 当想创建一个运行于多个类之间的对象，又不想生成新的子类时。 **代码实现：** ```java package mediator; import java.util.*; public class MediatorPattern { public static void main(String[] args) { Mediator md=new ConcreteMediator(); Colleague c1,c2; c1=new ConcreteColleague1(); c2=new ConcreteColleague2(); md.register(c1); md.register(c2); c1.send(); System.out.println("-------------"); c2.send(); } } // 抽象中介者 abstract class Mediator { public abstract void register(Colleague colleague); public abstract void relay(Colleague cl); // 转发 } // 具体中介者 class ConcreteMediator extends Mediator { private List<Colleague> colleagues=new ArrayList<Colleague>(); public void register(Colleague colleague) { if(!colleagues.contains(colleague)) { colleagues.add(colleague); colleague.setMedium(this); } } public void relay(Colleague cl) { for(Colleague ob:colleagues) { if(!ob.equals(cl)) { ((Colleague)ob).receive(); } } } } // 抽象同事类 abstract class Colleague { protected Mediator mediator; public void setMedium(Mediator mediator) { this.mediator=mediator; } public abstract void receive(); public abstract void send(); } // 具体同事类 class ConcreteColleague1 extends Colleague { public void receive() { System.out.println("具体同事类1收到请求。"); } public void send() { System.out.println("具体同事类1发出请求。"); mediator.relay(this); //请中介者转发 } } // 具体同事类 class ConcreteColleague2 extends Colleague { public void receive() { System.out.println("具体同事类2收到请求。"); } public void send() { System.out.println("具体同事类2发出请求。"); mediator.relay(this); //请中介者转发 } } ``` ### 3.8 命令模式（Command Pattern） **模式定义：** 将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，这样方便将命令对象进行储存、传递、调用、增加与管理。 **模式优点：** - 降低系统的耦合度。命令模式能将调用操作的对象与实现该操作的对象解耦。 - 增加或删除命令非常方便。采用命令模式增加与删除命令不会影响其他类，它满足“开闭原则”，对扩展比较灵活。 - 可以实现宏命令。命令模式可以与组合模式结合，将多个命令装配成一个组合命令，即宏命令。 - 方便实现 Undo 和 Redo 操作。命令模式可以与后面介绍的备忘录模式结合，实现命令的撤销与恢复。 **模式缺点：** - 可能产生大量具体命令类。因为计对每一个具体操作都需要设计一个具体命令类，这将增加系统的复杂性。 **应用场景：** - 当系统需要将请求调用者与请求接收者解耦时，命令模式使得调用者和接收者不直接交互。 - 当系统需要随机请求命令或经常增加或删除命令时，命令模式比较方便实现这些功能。 - 当系统需要执行一组操作时，命令模式可以定义宏命令来实现该功能。 - 当系统需要支持命令的撤销（Undo）操作和恢复（Redo）操作时，可以将命令对象存储起来，采用备忘录模式来实现。 **代码实现：** ```java package command; public class CommandPattern { public static void main(String[] args) { Command cmd=new ConcreteCommand(); Invoker ir=new Invoker(cmd); System.out.println("客户访问调用者的call()方法..."); ir.call(); } } // 调用者 class Invoker { private Command command; public Invoker(Command command) { this.command=command; } public void setCommand(Command command) { this.command=command; } public void call() { System.out.println("调用者执行命令command..."); command.execute(); } } // 抽象命令 interface Command { public abstract void execute(); } // 具体命令 class ConcreteCommand implements Command { private Receiver receiver; ConcreteCommand() { receiver=new Receiver(); } public void execute() { receiver.action(); } } // 接收者 class Receiver { public void action() { System.out.println("接收者的action()方法被调用..."); } } ``` ### 3.9 访问者模式（Visitor Pattern） **模式定义：** 将作用于某种数据结构中的各元素的操作分离出来封装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作，为数据结构中的每个元素提供多种访问方式。它将对数据的操作与数据结构进行分离，是行为类模式中最复杂的一种模式。 **模式优点：** - 扩展性好。能够在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能。 - 复用性好。可以通过访问者来定义整个对象结构通用的功能，从而提高系统的复用程度。 - 灵活性好。访问者模式将数据结构与作用于结构上的操作解耦，使得操作集合可相对自由地演化而不影响系统的数据结构。 - 符合单一职责原则。访问者模式把相关的行为封装在一起，构成一个访问者，使每一个访问者的功能都比较单一。 **模式缺点：** - 增加新的元素类很困难。在访问者模式中，每增加一个新的元素类，都要在每一个具体访问者类中增加相应的具体操作，这违背了“开闭原则”。 - 破坏封装。访问者模式中具体元素对访问者公布细节，这破坏了对象的封装性。 - 违反了依赖倒置原则。访问者模式依赖了具体类，而没有依赖抽象类。 **应用场景：** - 对象结构相对稳定，但其操作算法经常变化的程序。 - 对象结构中的对象需要提供多种不同且不相关的操作，而且要避免让这些操作的变化影响对象的结构。 - 对象结构包含很多类型的对象，希望对这些对象实施一些依赖于其具体类型的操作。 **代码实现：** ```java package visitor; import java.util.*; public class VisitorPattern { public static void main(String[] args) { ObjectStructure os=new ObjectStructure(); os.add(new ConcreteElementA()); os.add(new ConcreteElementB()); Visitor visitor=new ConcreteVisitorA(); os.accept(visitor); System.out.println("------------------------"); visitor=new ConcreteVisitorB(); os.accept(visitor); } } // 抽象访问者 interface Visitor { void visit(ConcreteElementA element); void visit(ConcreteElementB element); } // 具体访问者A类 class ConcreteVisitorA implements Visitor { public void visit(ConcreteElementA element) { System.out.println("具体访问者A访问-->"+element.operationA()); } public void visit(ConcreteElementB element) { System.out.println("具体访问者A访问-->"+element.operationB()); } } // 具体访问者B类 class ConcreteVisitorB implements Visitor { public void visit(ConcreteElementA element) { System.out.println("具体访问者B访问-->"+element.operationA()); } public void visit(ConcreteElementB element) { System.out.println("具体访问者B访问-->"+element.operationB()); } } // 抽象元素类 interface Element { void accept(Visitor visitor); } // 具体元素A类 class ConcreteElementA implements Element { public void accept(Visitor visitor) { visitor.visit(this); } public String operationA() { return "具体元素A的操作。"; } } // 具体元素B类 class ConcreteElementB implements Element { public void accept(Visitor visitor) { visitor.visit(this); } public String operationB() { return "具体元素B的操作。"; } } // 对象结构角色 class ObjectStructure { private List<Element> list=new ArrayList<Element>(); public void accept(Visitor visitor) { Iterator<Element> i=list.iterator(); while(i.hasNext()) { ((Element) i.next()).accept(visitor); } } public void add(Element element) { list.add(element); } public void remove(Element element) { list.remove(element); } } ``` ### 3.10 责任链模式（Chain of Responsibility Pattern） **模式定义：** 为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。 **模式优点：** - 降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理其请求以及链的结构，发送者和接收者也无须拥有对方的明确信息。 - 增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则。 - 增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，也可动态地新增或者删除责任。 - 责任链简化了对象之间的连接。每个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if···else 语句。 - 责任分担。每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。 **模式缺点：** - 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。 - 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。 - 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。 **应用场景：** - 有多个对象可以处理一个请求，哪个对象处理该请求由运行时刻自动确定。 - 可动态指定一组对象处理请求，或添加新的处理者。 - 在不明确指定请求处理者的情况下，向多个处理者中的一个提交请求。 **代码实现：** ```java package chainOfResponsibility; public class ChainOfResponsibilityPattern { public static void main(String[] args) { // 组装责任链 Handler handler1=new ConcreteHandler1(); Handler handler2=new ConcreteHandler2(); handler1.setNext(handler2); // 提交请求 handler1.handleRequest("two"); } } // 抽象处理者角色 abstract class Handler { private Handler next; public void setNext(Handler next) { this.next=next; } public Handler getNext() { return next; } // 处理请求的方法 public abstract void handleRequest(String request); } // 具体处理者角色1 class ConcreteHandler1 extends Handler { public void handleRequest(String request) { if(request.equals("one")) { System.out.println("具体处理者1负责处理该请求！"); } else { if(getNext()!=null) { getNext().handleRequest(request); } else { System.out.println("没有人处理该请求！"); } } } } // 具体处理者角色2 class ConcreteHandler2 extends Handler { public void handleRequest(String request) { if(request.equals("two")) { System.out.println("具体处理者2负责处理该请求！"); } else { if(getNext()!=null) { getNext().handleRequest(request); } else { System.out.println("没有人处理该请求！"); } } } } ``` ### 3.11 迭代器模式（Iterator Pattern） **模式定义：** 提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。 **模式优点：** - 访问一个聚合对象的内容而无须暴露它的内部表示。 - 遍历任务交由迭代器完成，这简化了聚合类。 - 它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。 - 增加新的聚合类和迭代器类都很方便，无须修改原有代码。 - 封装性良好，为遍历不同的聚合结构提供一个统一的接口。 **模式缺点：** - 增加了类的个数，这在一定程度上增加了系统的复杂性。 **应用场景：** - 当需要为聚合对象提供多种遍历方式时。 - 当需要为遍历不同的聚合结构提供一个统一的接口时。 - 当访问一个聚合对象的内容而无须暴露其内部细节的表示时。 **代码实现：** ```java package iterator; import java.util.*; public class IteratorPattern { public static void main(String[] args) { Aggregate ag=new ConcreteAggregate(); ag.add("中山大学"); ag.add("华南理工"); ag.add("韶关学院"); System.out.print("聚合的内容有："); Iterator it=ag.getIterator(); while(it.hasNext()) { Object ob=it.next(); System.out.print(ob.toString()+"\t"); } Object ob=it.first(); System.out.println("\nFirst："+ob.toString()); } } // 抽象聚合 interface Aggregate { public void add(Object obj); public void remove(Object obj); public Iterator getIterator(); } // 具体聚合 class ConcreteAggregate implements Aggregate { private List<Object> list=new ArrayList<Object>(); public void add(Object obj) { list.add(obj); } public void remove(Object obj) { list.remove(obj); } public Iterator getIterator() { return(new ConcreteIterator(list)); } } // 抽象迭代器 interface Iterator { Object first(); Object next(); boolean hasNext(); } // 具体迭代器 class ConcreteIterator implements Iterator { private List<Object> list=null; private int index=-1; public ConcreteIterator(List<Object> list) { this.list=list; } public boolean hasNext() { if(index<list.size()-1) { return true; } else { return false; } } public Object first() { index=0; Object obj=list.get(index);; return obj; } public Object next() { Object obj=null; if(this.hasNext()) { obj=list.get(++index); } return obj; } } ```