常见的设计模式详解

设计模式的类型

模式可以分为三大类：创建型模式、结构型模式、行为型模式。

GoF的23种设计模式：
在这里插入图片描述

设计模式的七大原则

1、开闭原则（Open Close Principle）
开闭原则的意思是：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

2、里氏代换原则（Liskov Substitution Principle）
里氏代换原则是面向对象设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。
里氏替换原则通俗来讲就是：子类可以扩展父类的功能，但不能改变父类原有的功能。也就是说：子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法。
通过重写父类的方法来完成新的功能写起来虽然简单，但是整个继承体系的可复用性会比较差，特别是运用多态比较频繁时，程序运行出错的概率会非常大。

3、依赖倒转原则（Dependence Inversion Principle）
这个原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。
高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。

4、接口隔离原则（Interface Segregation Principle）
这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。

5、迪米特法则，又称最少知道原则（Demeter Principle）
最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）
合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承。

单一职责原则（Single Responsibility Principle）
又称单一功能原则，这里的职责是指类变化的原因，单一职责原则规定一个类应该有且仅有一个引起它变化的原因，否则类应该被拆分。

一、创建型模式

创建型模式的主要关注点是“怎样创建对象？”，它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度，使用者不需要关注对象的创建细节，对象的创建由相关的工厂来完成。就像我们去商场购买商品时，不需要知道商品是怎么生产出来一样，因为它们由专门的厂商生产。

1. 工厂模式

工厂模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。

按实际业务场景划分，工厂模式有 3 种不同的实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式。

1. 简单工厂模式
简单工厂模式有一个具体的工厂类，可以生成多个不同的产品，属于创建型设计模式。
简单工厂模式不在 GoF 23 种设计模式之列。

简单工厂模式每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度，违背了“开闭原则”。

应用场景：
对于产品种类相对较少的情况，考虑使用简单工厂模式。使用简单工厂模式的客户端只需要传入工厂类的参数，不需要关心如何创建对象的逻辑，可以很方便地创建所需产品。

模式的结构：
简单工厂模式的主要角色如下：
● 简单工厂（SimpleFactory）：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
● 抽象产品（Product）：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。
● 具体产品（ConcreteProduct）：是简单工厂模式的创建目标。

2. 工厂方法模式
“工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。
应用场景：
● 客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。
● 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
● 客户不关心创建产品的细节，只关心产品的品牌

模式的结构：
工厂方法模式的主要角色如下。

抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

3. 抽象工厂模式
工厂方法模式中考虑的是一类产品的生产，如畜牧场只养动物、电视机厂只生产电视机、计算机科学学院只培养计算机软件专业的学生等。

同种类称为同等级，也就是说：工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类）的产品，如农场里既养动物又种植物，电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。

抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级（种类）的一组产品称为一个产品族，图 1 所示的是海尔工厂和 TCL 工厂所生产的电视机与空调对应的关系图。

工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

其缺点是：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。

模式的结构：
抽象工厂模式的主要角色如下。

抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。
应用举例
简单工厂模式：客户端想要获取不同的鼠标类别对象

//1.鼠标接口以及实现类
//抽象产品
public interface Mouse {
    
    
    void sayHi();
}
 
//具体产品
public class DellMouse implements Mouse{
    
    
    public void sayHi() {
    
    
        System.out.println("我是戴尔鼠标");
    }
}
 
//具体产品
public class HpMouse implements Mouse{
    
    
    public void sayHi() {
    
    
        System.out.println("我是惠普鼠标");
    }
}
//2.生产鼠标的工厂类：根据不同的参数返回不同类型的鼠标对象
//简单工厂
public class MouseFactory {
    
    
    public static Mouse createMouse(int type)
    {
    
    
        if(type==1)
            return new DellMouse();
        else if(type==2)
            return new HpMouse();
        else
            return new DellMouse();
    }
}
//3.客户端通过工厂类获取鼠标对象
public static void main(String[] args) {
    
    
        Mouse mouse=MouseFactory.createMouse(1);
        mouse.sayHi();
    }

工厂方法模式：例子同上，但是工厂方法模式的做法是让特定类型的工厂类生产特定类型的鼠标

//1.工厂接口
//抽象工厂
public interface MouseFactory {
    
    
    Mouse createMouse();
}
//2.生成不同鼠标的工厂子类
//具体工厂
public class DellMouseFactory implements MouseFactory {
    
    
    public Mouse createMouse() {
    
    
        return new DellMouse();//具体产品
    }
}

//具体工厂
public class HpMouseFactory implements MouseFactory {
    
    
    public Mouse createMouse() {
    
    
        return new HpMouse();//具体产品
    }
}
//3.客户端通过具体工厂类获取鼠标对象
public class Main {
    
    
    public static void main(String[] args) {
    
    
        MouseFactory mouseFactory=new DellMouseFactory();
        Mouse mouse=mouseFactory.createMouse();
        mouse.sayHi();
    }
}

抽象工厂模式：例子，不同工厂生产不同公司的键盘和鼠标套装

//1.添加键盘接口和实现类
public interface Keyboard {
    
    
    void sayHello();
}
public class DellKeyboard implements Keyboard {
    
    
    public void sayHello() {
    
    
        System.out.println("我是戴尔键盘");
    }
}
public class HpKeyboard implements Keyboard {
    
    
    public void sayHello() {
    
    
        System.out.println("我是惠普键盘");
    }
}
//2.工厂接口
public interface ComputerFactory {
    
    
    Mouse createMouse();
    Keyboard createKeyboard();
}
//3.工厂实现类
public class DellComputerFactory implements ComputerFactory {
    
    
    public Mouse createMouse() {
    
    
        return new DellMouse();
    }
    public Keyboard createKeyboard() {
    
    
        return new DellKeyboard();
    }
}
 
public class HpComputerFactory implements ComputerFactory {
    
    
    public Mouse createMouse() {
    
    
        return new HpMouse();
    }
    public Keyboard createKeyboard() {
    
    
        return new HpKeyboard();
    }
}
//4.客户端通过工厂获取一系列产品
public class Main {
    
    
    public static void main(String[] args) {
    
    
        ComputerFactory cf = new DellComputerFactory();
        Mouse mouse=cf.createMouse();
        Keyboard keyboard=cf.createKeyboard();
        mouse.sayHi();
        keyboard.sayHello();
    }
}

2. 单例模式

单例模式是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。

单例模式有 3 个特点：

单例类只有一个实例对象；

该单例对象必须由单例类自行创建；

单例类对外提供一个访问该单例的全局访问点。

● 单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。
● 单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。

单例模式通常有两种实现形式。

1. 懒汉式单例模式
该模式的特点是类加载时没有生成单例，只有当第一次调用 getlnstance 方法时才去创建这个单例。代码如下：

如果编写的是多线程程序，则不要删除上例代码中的关键字 volatile 和 synchronized，否则将存在线程非安全的问题。如果不删除这两个关键字就能保证线程安全，但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。

// 双检锁/双重校验锁（DCL，即 double-checked locking）
public class LazySingleton {
    
    
    // 保证 instance 在所有线程中同步
    private static volatile LazySingleton instance = null;

    // private 避免类在外部被实例化
    private LazySingleton() {
    
    
    }    

    public static synchronized LazySingleton getInstance() {
    
    
        // getInstance 方法前加同步
        if (instance == null) {
    
    
            instance = new LazySingleton();
        }
        return instance;
    }
}

2. 饿汉式单例模式
该模式的特点是类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了。

饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的，可以直接用于多线程而不会出现问题。

public class HungrySingleton {
    
    
    private static final HungrySingleton instance = new HungrySingleton();

    private HungrySingleton() {
    
    
    }

    public static HungrySingleton getInstance() {
    
    
        return instance;
    }
}

应用举例
【例1】用懒汉式单例模式模拟产生美国当今总统对象。
分析：在每一届任期内，美国的总统只有一人，所以本实例适合用单例模式实现。

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 {
    
    
    //保证instance在所有线程中同步
    private static volatile President instance = null;    

    //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("我是美国总统：特朗普。");
    }
}

程序运行结果如下：

产生一个总统！
我是美国总统：特朗普。
已经有一个总统，不能产生新总统！
我是美国总统：特朗普。
他们是同一人！

3. 原型模式

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。
在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。例如，Windows 操作系统的安装通常较耗时，如果复制就快了很多。

原型模式的优点：

Java 自带的原型模式基于内存二进制流的复制，在性能上比直接 new 一个对象更加优良。
可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份，并将其状态保存起来，简化了创建对象的过程，以便在需要的时候使用（例如恢复到历史某一状态），可辅助实现撤销操作。

原型模式的缺点：

需要为每一个类都配置一个 clone 方法。
clone 方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违背了开闭原则。
当实现深克隆时，需要编写较为复杂的代码，而且当对象之间存在多重嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来会比较麻烦。因此，深克隆、浅克隆需要运用得当。

模式的结构：
原型模式包含以下主要角色。

抽象原型类：规定了具体原型对象必须实现的接口。
具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
访问类：使用具体原型类中的 clone() 方法来复制新的对象。

原型模式的克隆分为浅克隆和深克隆。
● 浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。
● 深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

Java 中的 Object 类提供了浅克隆的 clone() 方法，具体原型类只要实现 Cloneable 接口就可实现对象的浅克隆，这里的 Cloneable 接口就是抽象原型类。

//具体原型类
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));
    }
}

4. 建造者模式

在软件开发过程中有时需要创建一个复杂的对象，这个复杂对象通常由多个子部件按一定的步骤组合而成。
例如，计算机是由 CPU、主板、内存、硬盘、显卡、机箱、显示器、键盘、鼠标等部件组装而成的，采购员不可能自己去组装计算机，而是将计算机的配置要求告诉计算机销售公司，计算机销售公司安排技术人员去组装计算机，然后再交给要买计算机的采购员。

造者模式的定义：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

该模式的主要优点如下：

封装性好，构建和表示分离。
扩展性好，各个具体的建造者相互独立，有利于系统的解耦。
客户端不必知道产品内部组成的细节，建造者可以对创建过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险。

其缺点如下：

产品的组成部分必须相同，这限制了其使用范围。
如果产品的内部变化复杂，如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大。

建造者模式和工厂模式的关注点不同：建造者模式注重零部件的组装过程，而工厂方法模式更注重零部件的创建过程，但两者可以结合使用。

模式的结构：
建造者模式的主要角色如下。

产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。
抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

二、结构型模式

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

1. 代理模式

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

代理模式的主要优点有：
● 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
● 代理对象可以扩展目标对象的功能；
● 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度，增加了程序的可扩展性。

其主要缺点是：
● 代理模式会造成系统设计中类的数量增加
● 在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢
● 增加了系统的复杂度

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

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

根据代理的创建时期，代理模式分为静态代理和动态代理。
● 静态：由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了。
● 动态：在程序运行时，运用反射机制动态创建而成。

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("代理结束。。。");
    }
}

2. 适配器模式

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

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

该模式的主要优点如下。
● 客户端通过适配器可以透明地调用目标接口。
● 复用了现存的类，程序员不需要修改原有代码而重用现有的适配者类。
● 将目标类和适配者类解耦，解决了目标类和适配者类接口不一致的问题。
● 在很多业务场景中符合开闭原则。

其缺点是：
● 适配器编写过程需要结合业务场景全面考虑，可能会增加系统的复杂性。
● 增加代码阅读难度，降低代码可读性，过多使用适配器会使系统代码变得凌乱。

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

//目标接口
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)对象适配器模式的代码如下
//对象适配器类 把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。
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();
    }
}

3. 桥接模式

在现实生活中，某些类具有两个或多个维度的变化，如图形既可按形状分，又可按颜色分。如不同颜色和字体的文字、不同品牌和功率的汽车、不同性别和职业的男女、支持不同平台和不同文件格式的媒体播放器等。

在软件系统中，某些类型由于自身的逻辑，它具有两个或多个维度的变化，那么如何应对这种“多维度的变化”？如何利用面向对象的技术来使得该类型能够轻松的沿着多个方向进行变化，而又不引入额外的复杂度？这就要使用Bridge模式。

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

桥接模式遵循了里氏替换原则和依赖倒置原则，最终实现了开闭原则，对修改关闭，对扩展开放。

桥接模式的优点是：
● 抽象与实现分离，扩展能力强
● 符合开闭原则
● 符合合成复用原则
● 其实现细节对客户透明

缺点是：
由于聚合关系建立在抽象层，要求开发者针对抽象化进行设计与编程，能正确地识别出系统中两个独立变化的维度，这增加了系统的理解与设计难度。

模式的结构：
桥接模式包含以下主要角色。

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

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();
    }
}

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

本实例按用途分可选钱包（Wallet）和挎包（HandBag），按颜色分可选黄色（Yellow）和红色（Red）。可以按两个维度定义为颜色类和包类。

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

//实现化角色：颜色
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";
    }
}

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);
    }
}

4. 装饰器模式

上班族大多都有睡懒觉的习惯，每天早上上班时间都很紧张，于是很多人为了多睡一会，就会用方便的方式解决早餐问题。有些人早餐可能会吃煎饼，煎饼中可以加鸡蛋，也可以加香肠，但是不管怎么“加码”，都还是一个煎饼。在现实生活中，常常需要对现有产品增加新的功能或美化其外观，如房子装修、相片加相框等，都是装饰器模式。

在软件开发过程中，有时想用一些现存的组件。这些组件可能只是完成了一些核心功能。但在不改变其结构的情况下，可以动态地扩展其功能。所有这些都可以釆用装饰器模式来实现。

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

装饰器模式的主要优点有：
● 装饰器是继承的有力补充，比继承灵活，在不改变原有对象的情况下，动态的给一个对象扩展功能，即插即用。
● 通过使用不用装饰类及这些装饰类的排列组合，可以实现不同效果。
● 装饰器模式完全遵守开闭原则。

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

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

模式的结构：
装饰器模式主要包含以下角色。

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

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()

5. 外观模式

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

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

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

在日常编码工作中，我们都在有意无意的大量使用外观模式。只要是高层模块需要调度多个子系统（2个以上的类对象），我们都会自觉地创建一个新的类封装这些子系统，提供精简的接口，让高层模块可以更加容易地间接调用这些子系统的功能。尤其是现阶段各种第三方SDK、开源类库，很大概率都会使用外观模式。

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

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

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

不能很好地限制客户使用子系统类，很容易带来未知风险。
增加新的子系统可能需要修改外观类或客户端的源代码，违背了“开闭原则”。

外观模式的结构比较简单，主要是定义了一个高层接口。它包含了对各个子系统的引用，客户端可以通过它访问各个子系统的功能。

模式的结构：
外观模式包含以下主要角色。

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

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()被调用！");
    }
}

6. 组合模式

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

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

组合模式一般用来描述整体与部分的关系，它将对象组织到树形结构中，顶层的节点被称为根节点，根节点下面可以包含树枝节点和叶子节点，树枝节点下面又可以包含树枝节点和叶子节点，树形结构图如下。

在组合模式中，整个树形结构中的对象都属于同一种类型，带来的好处就是用户不需要辨别是树枝节点还是叶子节点，可以直接进行操作，给用户的使用带来极大的便利。

组合模式的主要优点有：

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

其主要缺点是：

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

模式的结构：
组合模式包含以下主要角色。

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

组合模式分为透明式的组合模式和安全式的组合模式。
(1) 透明方式
在该方式中，由于抽象构件声明了所有子类中的全部方法，所以客户端无须区别树叶对象和树枝对象，对客户端来说是透明的。但其缺点是：树叶构件本来没有 Add()、Remove() 及 GetChild() 方法，却要实现它们（空实现或抛异常），这样会带来一些安全性问题。
(2) 安全方式
在该方式中，将管理子构件的方法移到树枝构件中，抽象构件和树叶构件没有对子对象的管理方法，这样就避免了上一种方式的安全性问题，但由于叶子和分支有不同的接口，客户端在调用时要知道树叶对象和树枝对象的存在，所以失去了透明性。

三、行为模式

行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配。

行为型模式分为类行为模式和对象行为模式，前者采用继承机制来在类间分派行为，后者采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象行为模式比类行为模式具有更大的灵活性。

1. 职责链模式

在现实生活中，一个事件需要经过多个对象处理是很常见的场景。例如，采购审批流程、请假流程等。公司员工请假，可批假的领导有部门负责人、副总经理、总经理等，但每个领导能批准的天数不同，员工必须根据需要请假的天数去找不同的领导签名，也就是说员工必须记住每个领导的姓名、电话和地址等信息，这无疑增加了难度。

在计算机软硬件中也有相关例子，如总线网中数据报传送，每台计算机根据目标地址是否同自己的地址相同来决定是否接收；还有异常处理中，处理程序根据异常的类型决定自己是否处理该异常。

职责链模式的定义：为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

在职责链模式中，客户只需要将请求发送到责任链上即可，无须关心请求的处理细节和请求的传递过程，请求会自动进行传递。所以职责链将请求的发送者和请求的处理者解耦了。

职责链模式是一种对象行为型模式，其主要优点如下。

降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理其请求以及链的结构，发送者和接收者也无须拥有对方的明确信息。
增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则。
增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，也可动态地新增或者删除责任。
责任链简化了对象之间的连接。每个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if···else 语句。
责任分担。每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。

其主要缺点如下。

不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。
职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。

职责链模式的独到之处是将其节点处理者组合成了链式结构，并允许节点自身决定是否进行请求处理或转发，相当于让请求流动起来。

模式的结构：
职责链模式主要包含以下角色。

抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

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("没有人处理该请求！");
            }
        }
    }
}

2. 命令模式

在现实生活中，命令模式的例子也很多。比如看电视时，我们只需要轻轻一按遥控器就能完成频道的切换，这就是命令模式，将换台请求和换台处理完全解耦了。电视机遥控器（命令发送者）通过按钮（具体命令）来遥控电视机（命令接收者）。再比如，我们去餐厅吃饭，菜单不是等到客人来了之后才定制的，而是已经预先配置好的。这样，客人来了就只需要点菜，而不是任由客人临时定制。餐厅提供的菜单就相当于把请求和处理进行了解耦，这就是命令模式的体现。

命令模式的定义如下：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，这样方便将命令对象进行储存、传递、调用、增加与管理。

命令模式的主要优点如下。

通过引入中间件（抽象接口）降低系统的耦合度。
扩展性良好，增加或删除命令非常方便。采用命令模式增加与删除命令不会影响其他类，且满足“开闭原则”。
可以实现宏命令。命令模式可以与组合模式结合，将多个命令装配成一个组合命令，即宏命令。
方便实现 Undo 和 Redo 操作。命令模式可以与备忘录模式结合，实现命令的撤销与恢复。
可以在现有命令的基础上，增加额外功能。比如日志记录，结合装饰器模式会更加灵活。

其缺点是：

可能产生大量具体的命令类。因为每一个具体操作都需要设计一个具体命令类，这会增加系统的复杂性。
命令模式的结果其实就是接收方的执行结果，但是为了以命令的形式进行架构、解耦请求与实现，引入了额外类型结构（引入了请求方与抽象命令接口），增加了理解上的困难。不过这也是设计模式的通病，抽象必然会额外增加类的数量，代码抽离肯定比代码聚合更加难理解。

模式的结构:
命令模式包含以下主要角色。

抽象命令类（Command）角色：声明执行命令的接口，拥有执行命令的抽象方法 execute()。
具体命令类（Concrete Command）角色：是抽象命令类的具体实现类，它拥有接收者对象，并通过调用接收者的功能来完成命令要执行的操作。
实现者/接收者（Receiver）角色：执行命令功能的相关操作，是具体命令对象业务的真正实现者。
调用者/请求者（Invoker）角色：是请求的发送者，它通常拥有很多的命令对象，并通过访问命令对象来执行相关请求，它不直接访问接收者。

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()方法被调用...");
    }
}