23种设计模式解析

一、设计模式的分类

1.1 三大类

创建型模式，共五种：单例模式、抽象工厂模式、工厂方法模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

1.2 简述

1.2.1 创建型

Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点
Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。
Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。
Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。
Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。

1.2.2 行为型

Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。
Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。
Template Method，模板方法：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMethod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。
Command，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作。
State，状态模式：允许对象在其内部状态改变时改变他的行为。对象看起来似乎改变了他的类。
Strategy，策略模式：定义一系列的算法，把他们一个个封装起来，并使他们可以互相替换，本模式使得算法可以独立于使用它们的客户。
Chain of Responsibility，职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系
Mediator，中介者模式：用一个中介对象封装一些列的对象交互。
Visitor，访问者模式：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这个元素的新操作。
Interpreter，解释器模式：给定一个语言，定义他的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
Memento，备忘录模式：在不破坏对象的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。

1.2.3 结构型

Composite，组合模式：将对象组合成树形结构以表示部分整体的关系，Composite使得用户对单个对象和组合对象的使用具有一致性。
Facade，外观模式：为子系统中的一组接口提供一致的界面，Facade提供了一高层接口，这个接口使得子系统更容易使用。
Proxy，代理模式：为其他对象提供一种代理以控制对这个对象的访问
Adapter,适配器模式：将一类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作那些类可以一起工作。
Decrator，装饰模式：动态地给一个对象增加一些额外的职责，就增加的功能来说，Decorator模式相比生成子类更加灵活。
Bridge，桥模式：将抽象部分与它的实现部分相分离，使他们可以独立的变化。
Flyweight，享元模式

1.3 设计模式的六大原则

1.3.1 开闭原则（Open Close Principle）

• 开闭原则就是说对扩展开放，对修改关闭。
• 在程序需要进行拓展的时候，不能去修改原有的代码。
• 程序得有强扩展性，易于维护和升级。
• 所以需要使用接口和抽象类。

1.3.2 里氏代换原则（Liskov Substitution Principle）

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

1.3.3 依赖倒转原则（Dependence Inversion Principle）

这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。

1.3.4 接口隔离原则（Interface Segregation Principle）

• 使用多个隔离的接口，比使用单个接口要好；
• 降低类之间的耦合度

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

一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

1.3.6 合成复用原则（Composite Reuse Principle）

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

二、23 种设计模式的详解

2.1 工厂方法模式（Factory Method）

2.1.1 普通工厂模式

就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

创建思路：

• 一个接口
• 实现接口的一些类
• 一个工厂类：用来创建类实例

例子

比如，我们想让一张纸打印出符合特定模板的内容，

创建过程：

• 一个接口——初始模板
• 实现接口的一些类——改进模板
• 一个工厂类：用来创建类实例——打印机
• 比如，一台打印机是用来打印的工厂，我们设定一个初始模板，然后根据这个模板发展出改进模板。

public interface Template {
    void Print();
}

public class HelloTemplate implements Template {
    @Override
    public void Print() {
        System.out.println("this is HelloTemplate!");
    }
}
public class WorldTemplate implements Template {

    @Override
    public void Print() {
        System.out.println("this is WorldTemplate!");
    }
}

public class Printer {

    public Template produce(String type) {
        if ("Hello".equals(type)) {
            return new HelloTemplate();
        } else if ("World".equals(type)) {
            return new WorldTemplate();
        } else {
            System.out.println("请输入正确的类型!");
            return null;
        }
    }
}

public class FactoryTest {
    public static void main(String[] args) {
        Printer printer = new Printer();
        Template tmp1 = printer.produce("Hello");
        Template tmp2 = printer.produce("World");
        tmp1.Print();
        tmp2.Print();
    }
}

2.1.2 多个工厂方法模式

原来通过传入字符串的方式来决定返回哪个类的方法，是不合理的，因为如果传入的字符串有误，不能正确创建对象，这样会不利于扩展新类。
所以这里改变对工厂类进行了改变。

public class Printer {

    public Template produceHello() {
        return new HelloTemplate();
    }
    public Template produceWorld() {
        return new WorldTemplate();
    }
}

修改后的调用方式如下

public class FactoryTest {
    public static void main(String[] args) {
        Printer printer = new Printer();
        Template tmp1 = printer.produceHello();
        Template tmp2 = printer.produceWorld();
        tmp1.Print();
        tmp2.Print();
    }
}

2.1.3 静态工厂方法模式

将多个工厂方法模式里的方法置为静态的，就不需要创建实例，直接调用即可。
大多数情况下，我们会选用此模式。

public class Printer {

	//注意是在这里加上static 
    public static Template produceHello() {
        return new HelloTemplate();
    }
    public static Template produceWorld() {
        return new WorldTemplate();
    }
}

直接调用

public class FactoryTest {
	
    public static void main(String[] args) {
    	//注意这里没有创建Printer，就直接调用了produceHello和produceWorld方法
        Template template1 = Printer.produceHello();
        Template template2 = Printer.produceWorld();
        template1.Print();
        template2.Print();
    }
}

2.2 抽象工厂模式（Abstract Factory）

工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则。
所以想法是，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

创建思路：

• 一个接口
• 实现接口的n个类
• 一个工厂接口
• 实现工厂接口的n个工厂类：其中分别对应调用了实现接口的n个类

例子

比如，我们想让制造多个种类的车辆。

创建过程：

• 一个接口：车辆模板
• 实现接口的n个类：不同种类
• 一个工厂接口：车辆制造厂
• 实现工厂接口的n个工厂类：其中分别对应调用了实现接口的n个类：不同种类车辆的制造厂

// 接口：车辆模板
public interface Car {
    public void run();
}

// 实现接口的类：皮卡
public class Pickup implements Car{
    @Override
    public void run() {
        System.out.println("Pickup run.");
    }
}

// 实现接口的类：跑车
public class Roadster implements Car{
    @Override
    public void run() {
        System.out.println("Roadster run.");
    }
}

// 接口：工厂模板
public interface Factory {
    public Car make();
}

// 接实现工厂接口的类：皮卡工厂
public class PickupFactory implements Factory{
    @Override
    public Car make() {
        System.out.println("Make a Pickup.");
        return new Pickup();
    }
}

// 接实现工厂接口的类：跑车工厂
public class RoadsterFactory implements Factory{
    @Override
    public Car make() {
        System.out.println("Make a Roadster.");
        return new Roadster();
    }
}

public class FactoryTest {
    public static void main(String[] args) {
    	// 先建皮卡工厂
        Factory pickupFactory = new PickupFactory();
        // 皮卡工厂生产皮卡
        Car pickup = pickupFactory.make();
        // 测试皮卡跑
        pickup.run();

        Factory roadsterFactory = new RoadsterFactory();
        Car roadster = roadsterFactory.make();
        roadster.run();
    }
}

2.3 单例模式（Singleton）

在 Java 应用中，单例对象能保证在一个 JVM中，该对象只有一个实例存在。

1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。
2、省去了 new 操作符，降低了系统内存的使用频率，减轻 GC 压力。
3、有的类要求只能创建一次。

创建思路

• 私有构造方法，防止被实例化
• 使用一个内部类来维护单例——private static
• 获取实例的方法——返回instance
• 保证对象在序列化前后保持一致的方法——返回获取实例的方法

public class Singleton {
    /* 私有构造方法，防止被实例化 */
    private Singleton() {
    }

    /* 此处使用一个内部类来维护单例 */
    private static class SingletonFactory {
        private static Singleton instance = new Singleton();
    }

    /* 获取实例 */
    public static Singleton getInstance() {
        return SingletonFactory.instance;
    }

    /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */
    public Object readResolve() {
        return getInstance();
    }
}

为何这个创建方法是线程安全的？

• 单例模式使用内部类来维护单例的实现，JVM 内部的机制能够保证当一个类
• 被加载的时候，这个类的加载过程是线程互斥的。
• 这样当我们第一次调用 getInstance 的时候，JVM 能够帮我们保证instance 只被创建一次，并且会保证把赋值给 instance 的内存初始化完毕。
• 同时该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低性能问题。

2.4 建造者模式（Builder）

建造者模式将各种产品集中起来进行管理，用来创建复合对象
所谓复合对象就是指某个类具有不同的属性
建造者模式 = 抽象工厂模式 + 最后的Test。

不通过工厂来造车，而是通过一个类中的多个流水线（方法），批量造不同种类的车

创建思路

• 一个接口：车辆模板
• 实现接口的n个类：不同种类
• 批量生产各种车的Builder类

public class Builder {

    private List<Car> list = new ArrayList<Car>();

    public void producePickup(int count){
        for(int i=0; i<count; i++){
            list.add(new Pickup());
        }
    }

    public void produceRoadster(int count){
        for(int i=0; i<count; i++){
            list.add(new Roadster());
        }
    }
}

public class BuilderTest {
    public static void main(String[] args) {
        Builder builder = new Builder();
        // 批量生产10辆皮卡
        builder.producePickup(10);
        // 批量生产5辆跑车
        builder.produceRoadster(5);
    }
}

2.5 原型模式（Prototype）

该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。

创建思路

• 创建一个类
• 该类实现Cloneable接口
• 创建clone()方法，返回Object类，抛出CloneNotSupportedException 异常
• 在方法中Prototype proto = (Prototype) super.clone(); 并return proto;

public class Prototype implements Cloneable { 
	public Object clone() throws CloneNotSupportedException { 
		// 重点是super.clone()这句话，super.clone()调用的是Object的clone()方法，而在Object 类中，clone()是 native 的
		Prototype proto = (Prototype) super.clone(); 
		return proto; 
	} 
} 

浅复制（不彻底）：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。

深复制（完全彻底）：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。

 public class Prototype implements Cloneable, Serializable {

    private static final long serialVersionUID = 1L;
    private String string;

    private SerializableObject obj;

    /* 浅复制：简单，同上 */
    public Object clone() throws CloneNotSupportedException {
        Prototype proto = (Prototype) super.clone();
        return proto;
    }

    /* 
    深复制： 
	    写入当前对象的二进制流，
	    返回读二进制流产生的新对象
	*/
    public Object deepClone() throws IOException, ClassNotFoundException {

        /* 写入当前对象的二进制流 */
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);

        /* 读出二进制流产生的新对象 */
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray(
        ));
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }

    public String getString() {
        return string;
    }

    public void setString(String string) {
        this.string = string;
    }

    public SerializableObject getObj() {
        return obj;
    }

    public void setObj(SerializableObject obj) {
        this.obj = obj;
    }

}
// 实现序列化方法
class SerializableObject implements Serializable {
    private static final long serialVersionUID = 1L;
} 

2.6 适配器模式（Adapter）

2.6.1 类的适配器模式

核心思想：

• 创建一个 Source 类，拥有一个待适配的方法methodWaited；
• 目标接口 Targetable；
• 创建 Adapter 类，通过继承 Source，实现 Targetable，将 Source 的方法methodWaited扩展到 Adapter 里

场景：
可知：不同的插座适用于不同的设备
如果：我们只有一种类型的设备却找不到其适用的插座
需求：就需要找到一个可以将现有插座和现有设备连接起来的目标转换器。

核心思路：

• 现有插座：Socket类，拥有一个待适配的方法PowerSupply
• 目标转换器：目标接口 Switch；
• 现有插头：Device 类，通过继承 Socket，实现 Switch，将 Socket 的方法PowerSupply 扩展到 Device 里

public class Socket {
    public void PowerSupply(){
        System.out.println("Charging......");
    }
}

public interface Switch {
    public void PowerSupply();
    public void OpenUp();
}

public class Device extends Socket implements Switch{

    @Override
    public void OpenUp() {
        System.out.println("Starting up......");
    }
}

public class Test {
    public static void main(String[] args) {
        Device device = new Device();
        device.OpenUp();
        device.PowerSupply();
    }
}

应用场景：
当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。

2.6.2 对象的适配器模式

基本思路
将 Adapter 类作修改，这次不继承Source 类，而是持有 Source 类的实例，以达到解决兼容性的问题。

核心思想：

• 创建一个 Source 类，拥有一个待适配的方法methodWaited；
• 目标接口 Targetable；
• 创建 Adapter 类，通过实现 Targetable，持有 Source 类的实例，将 Source 的方法methodWaited扩展到 Adapter 里

场景：
可知：不同的插座适用于不同的设备
如果：我们只有一种类型的设备却找不到其适用的插座
需求：就需要找到一个可以将现有插座和现有设备连接起来的目标转换器。

核心思路：

• 现有插座：Socket类，拥有一个待适配的方法PowerSupply
• 目标转换器：目标接口 Switch；
• 现有插头：Device 类，通过继承 Socket，持有 Switch 类的实例，将 Socket 的方法PowerSupply 扩展到 Device 里

public class Device implements Switch {

    private Socket socket;

    public Device(Socket s){
        super();
        socket=s;
    }

    @Override
    public void PowerSupply() {
        socket.PowerSupply();
    }

    @Override
    public void OpenUp() {
        System.out.println("Starting up......");
    }
}

public class Test {
    public static void main(String[] args) {
        Socket socket = new Socket();
        Device device = new Device(socket);
        device.OpenUp();
        device.PowerSupply();
    }
}

应用场景：
当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper 类，持有原类的一个实例，在Wrapper 类的方法中，调用实例的方法就行。

2.6.3 接口的适配器模式

• 问题：有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的；
• 接口的适配器模式思想：借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系。也即：写一个类，继承该抽象类，重写我们需要的方法就行；

核心思想：

• 创建一个接口，拥有数个方法；
• 创建一个抽象类，实现接口；
• 创建几个类，继承抽象类，并实现想实现的方法。

场景：
可知：一栋大楼有很多房间
如果：房东有所有房间的钥匙，而我们只想进去其中的几间
需求：就需要各取所需的从房东那里打新钥匙。

核心思路：

• 一栋大楼的所有房间：接口Building，有room1,room2等方法
• 房东的钥匙们：抽象类KeyOrigin，内有room1,room2等方法的实现；
• 个人持有的钥匙：KeyPerson1类，继承KeyOrigin类，然后实现自己的房间的方法。比如Person1有room2，room3。

public interface Building {
    public void room1();
    public void room2();
    public void room3();
    public void room4();
}

public abstract class KeyOrigin implements Building{

    public void room1() {}
    public void room2() {}
    public void room3() {}
    public void room4() {}
}

public class Person1 extends KeyOrigin{
    public void room2(){
        System.out.println("I own room2");
    }
    public void room3(){
        System.out.println("I own room3");
    }
}

public class Person2 extends KeyOrigin{
    public void room1(){
        System.out.println("I own room1");
    }
}

public class Test {
    public static void main(String[] args) {
        KeyOrigin person1=new Person1();
        person1.room2();
        person1.room3();

        KeyOrigin person2=new Person2();
        person2.room1();
    }
}

应用场景：
当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。

2.7 装饰模式（Decorator）

给一个对象增加一些新的功能，而且是动态的；
要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。

核心思想：

• Sourceable 是接口，其中有method方法；
• Source 类是被装饰类，实现Sourceable，实现method方法；
• Decorator 类是一个装饰类，实现Sourceable，在它的构造方法中传入 Source 类实例，在实现method方法中调用 Source 类实例的method方法；

场景：
可知：我们要做汉堡，汉堡有三层，其上下均为面包，其中间为肉饼和菜；
需求：我们有肉饼和菜，要添加上其上下的面包；

核心思路：

• Maker 是接口，其中有makeHamburger方法；
• MeatPie 类是被装饰类，实现Maker，实现makeHamburger方法；
• Bread 类是一个装饰类，实现Maker，在它的构造方法中传入 Maker 类实例，在实现的makeHamburger方法中调用 MeatPie 类实例的makeHamburger方法；

public interface Maker {
    public void makeHamburger();
}

public class MeatPie implements Maker{
    @Override
    public void makeHamburger() {
        System.out.println("Ketchup");
        System.out.println("Vegetable");
        System.out.println("Meat Pie");
    }
}

public class Bread implements Maker{

    private Maker maker;

    public Bread(Maker meatpie){
        super();
        maker=meatpie;
    }

    @Override
    public void makeHamburger() {
        System.out.println("Bread");
        maker.makeHamburger();
        System.out.println("Bread");
    }
}

public class Test {
    public static void main(String[] args) {
        Maker meatPie = new MeatPie();
        Bread bread = new Bread(meatPie);
        bread.makeHamburger();
    }
}

2.8 代理模式（Proxy）

代理模式就是多一个代理类出来，替原对象进行一些操作。
目的也就是：让专业的人做专业的事。

结构：

• Sourceable 是接口，其中有method方法；
• Source 类，实现Sourceable，实现method方法；
• Proxy 类是一个代理类，实现Sourceable，在它的构造方法中new一个 Source 类实例，在实现method方法中调用 Source 类实例的method方法。

场景：
可知：我们要做汉堡，汉堡有三层，其上下均为面包，其中间为肉饼和菜；
需求：我们有肉饼和菜，要添加上其上下的面包；

核心思路：

• Maker 是接口，其中有makeHamburger方法；
• MeatPie 类，实现Maker，实现makeHamburger方法；
• BreadAdder 类是一个代理类，实现Maker，在它的构造方法中new一个 MeatPie 类实例，在实现的makeHamburger方法中调用 MeatPie 类实例的makeHamburger方法；

public interface Maker {
    public void makeHamburger();
}

public class MeatPie implements Maker {
    @Override
    public void makeHamburger() {
        System.out.println("Ketchup");
        System.out.println("Vegetable");
        System.out.println("Meat Pie");
    }
}

public class BreadAdder implements Maker {

    private Maker maker;

    public BreadAdder(){
        super();
        maker=new MeatPie();
    }

    @Override
    public void makeHamburger() {
        before();
        maker.makeHamburger();
        after();
    }

    public void before(){
        System.out.println("Bread");
    }

    public void after(){
        System.out.println("Bread");
    }
}

public class Test {
    public static void main(String[] args) {
        BreadAdder bread = new BreadAdder();
        bread.makeHamburger();
    }
}

2.9 外观模式（Facade）

外观模式就是将类之家的依赖关系放在一个Facade 类中，降低了类类之间的耦合度，该模式中没有涉及到接口。

该方法比较直观，下面是抽象开启电脑的代码，我们直接看代码：

public class CPU {

    public void startup(){
        System.out.println("cpu startup!");
    }

    public void shutdown(){
        System.out.println("cpu shutdown!");
    }
}

public class Disk {
    public void startup(){
        System.out.println("disk startup!");
    }

    public void shutdown(){
        System.out.println("disk shutdown!");
    }
}

public class Memory {

    public void startup(){
        System.out.println("memory startup!");
    }
    public void shutdown(){
        System.out.println("memory shutdown!");
    }
}

public class Computer {
    private CPU cpu;
    private Memory memory;
    private Disk disk;

    public Computer(){
        cpu = new CPU();
        memory = new Memory();
        disk = new Disk();
    }

    public void startup(){
        System.out.println("start the computer!");
        cpu.startup();
        memory.startup();
        disk.startup();
        System.out.println("start computer finished!");
    }

    public void shutdown(){
        System.out.println("begin to close the computer!");
        cpu.shutdown();
        memory.shutdown();
        disk.shutdown();
        System.out.println("computer closed!");
    }
}

public class User {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.startup();
        computer.shutdown();
    }
}

2.10 桥接模式（Bridge）

桥接模式就是把事物和其具体实现分开，使他们可以各自独立的变化。

桥接的用意是：将抽象化与实现化解耦，使得二者可以独立变化

e.g. JDBC 桥 DriverManager：JDBC 进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不用动，原因就是JDBC 提供统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了。

结构：

• 一个接口：Sourceable
• 接口的n个实现类：SourceSub1、SourceSub2 …
• 定义一个桥(abstract)，持有 Sourceable 的一个实例
• 继承桥的类

场景：
可知：我们要用同样的方式，连接几个不同的数据库

核心思路：

• 一个接口：DatabaseTemplate
• 接口的n个实现类：Database1、Database2 …
• 定义一个桥AbstractManager，持有 DatabaseTemplate 的一个实例
• 继承桥的类DriverManager

public interface DatabaseTemplate {
    public void build();
}

public class MySQL implements DatabaseTemplate{

    @Override
    public void build() {
        System.out.println("Build MySQL");
    }
}

public class PostgreSQL implements DatabaseTemplate{

    @Override
    public void build() {
        System.out.println("Build PostgreSQL");
    }
}

public abstract class AbstractManager {
    private DatabaseTemplate template;

    public void setDatabase(DatabaseTemplate databaseTemplate){
        template=databaseTemplate;
    }

    public DatabaseTemplate getDatabase(){
        return template;
    }

    public void build(){
        template.build();
    }
}

public class DriverManager extends AbstractManager{
    public void build(){
        getDatabase().build();
    }
}

public class Test {
    public static void main(String[] args) {
        AbstractManager driverManager = new DriverManager();

        MySQL mySQL = new MySQL();
        driverManager.setDatabase(mySQL);
        driverManager.build();

        PostgreSQL postgreSQL = new PostgreSQL();
        driverManager.setDatabase(postgreSQL);
        driverManager.build();
    }
}

2.11 组合模式（Composite）

• 有时又叫部分-整体模式
• 在处理类似树形结构的问题时比较方便

public class TreeNode {
    private String name;
    private TreeNode parent;
    private Vector<TreeNode> children = new Vector<TreeNode>();

    public TreeNode(String name){
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public TreeNode getParent() {
        return parent;
    }
    public void setParent(TreeNode parent) {
        this.parent = parent;
    }

    //添加孩子节点
    public void add(TreeNode node){
        children.add(node);
    }

    //删除孩子节点
    public void remove(TreeNode node){
        children.remove(node);
    }

    //取得孩子节点
    public Enumeration<TreeNode> getChildren(){
        return children.elements();
    }
}

public class Tree {
    TreeNode root = null;

    public Tree(String name) {
        root = new TreeNode(name);
    }

    public static void main(String[] args) {
        Tree tree = new Tree("A branch");
        TreeNode nodeB = new TreeNode("B branch");
        TreeNode nodeC = new TreeNode("C branch");

        nodeB.add(nodeC);
        tree.root.add(nodeB);
        System.out.println("Grow the tree finished!");
    }
}

2.12 享元模式（Flyweight）

享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。

• FlyWeightFactory 负责创建和管理享元单元，当一个客户端请求时，工厂需要检查当前对象池中是否有符合条件的对象，如果有，就返回已经存在的对象，如果没有，则创建一个新对象；
• FlyWeight 是超类。

e.g. Java 里面的JDBC 连接池

• 适用于作共享的一些个对象，他们有一些共有的属性，url、driverClassName、username、password 及dbname，这些属性对于每个连接来说都是一样的，所以就适合用享元模式来处理
• 建一个工厂类，将上述类似属性作为内部数据，其它的作为外部数据，在方法调用时，当做参数传进来，这样就节省了空间，减少了实例的数量。

public class ConnectionPool {
    private Vector<Connection> pool;

    /*公有属性*/
    private String url = "jdbc:mysql://localhost:3306/test";
    private String username = "root";
    private String password = "root";
    private String driverClassName = "com.mysql.jdbc.Driver";
    private int poolSize = 100;
    private static ConnectionPool instance = null;
    Connection conn = null;

    /*构造方法，做一些初始化工作*/
    private ConnectionPool() {
        pool = new Vector<Connection>(poolSize);

        for (int i = 0; i < poolSize; i++) {
            try {
                Class.forName(driverClassName);
                conn = DriverManager.getConnection(url, username, password);
                pool.add(conn);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /* 返回连接到连接池 */
    public synchronized void release() {
        pool.add(conn);
    }

    /* 返回连接池中的一个数据库连接 */
    public synchronized Connection getConnection() {
        if (pool.size() > 0) {
            Connection conn = pool.get(0);
            pool.remove(conn);
            return conn;
        } else {
            return null;
        }
    }
}

2.13 策略模式（strategy）

模式结构

• 定义一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。
• 设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，
• 设计一个抽象类（可有可无，属于辅助类），提供辅助函数

场景
一个计算器，其中包含有减法、加法、乘法、除法等运算

设计思路

• 设计一个接口ICalculator，为一系列实现类提供统一的方法，多个实现类实现该接口
• 定义一系列类，Minus、Plus、Multiply、Division，其中均有calculate方法，在方法中实现不同的算法；
• 设计一个抽象类AbstractCalculator，提供辅助函数

public interface ICalculator {
    public int calculate(String exp);
}

public abstract class AbstractCalculator {
    public int[] split(String exp,String opt){
        String array[] = exp.split(opt);
        int arrayInt[] = new int[2];
        arrayInt[0] = Integer.parseInt(array[0]);
        arrayInt[1] = Integer.parseInt(array[1]);
        return arrayInt;
    }
}

public class Plus extends AbstractCalculator implements ICalculator {

    @Override
    public int calculate(String exp) {
        int arrayInt[] = split(exp,"\\+");
        return arrayInt[0]+arrayInt[1];
    }
}

public class Divide extends AbstractCalculator implements ICalculator{

    @Override
    public int calculate(String exp) {
        int arrayInt[] = split(exp,"/");
        return arrayInt[0]/arrayInt[1];
    }
}

省略 Minus和Multiply类的建立过程，类似。

public class StrategyTest {
    public static void main(String[] args) {
        String exp = "8/2";
        ICalculator cal = new Divide();
        int result = cal.calculate(exp);
        System.out.println(result);
    }
}

2.14 模板方法模式（Template Method）

模式结构

• 一个抽象类中，有一个主方法，再定义1…n 个方法，可以是抽象的，也可以是实际的方法
• 定义一个类，继承该抽象类，重写抽象方法
• 通过调用抽象类，实现对子类的调用

场景
一个计算器，其中包含有减法、加法、乘法、除法等运算

设计思路

• 一个抽象类AbstractCalculator中，有一个主方法calculate，再定义1…n 个方法，可以是抽象的，也可以是实际的方法
• 定义几个类，比如Plus、Minus，继承抽象类AbstractCalculator，重写抽象方法
• 通过调用抽象类AbstractCalculator，实现对子类的调用

public abstract class AbstractCalculator {

    /*主方法，实现对本类其它方法的调用*/
    public final int calculate(String exp,String opt){
        int array[] = split(exp,opt);
        return calculate(array[0],array[1]);
    }

    /*被子类重写的方法*/
    abstract public int calculate(int num1,int num2);

    public int[] split(String exp,String opt){
        String array[] = exp.split(opt);
        int arrayInt[] = new int[2];
        arrayInt[0] = Integer.parseInt(array[0]);
        arrayInt[1] = Integer.parseInt(array[1]);
        return arrayInt;
    }
}

public class Plus extends AbstractCalculator {

    @Override
    public int calculate(int num1,int num2) {
        return num1 + num2;
    }
}

public class Minus extends AbstractCalculator {

    @Override
    public int calculate(int num1, int num2) {
        return num1 - num2;
    }
}

public class Test {
    public static void main(String[] args) {
        String exp = "4+8";
        AbstractCalculator cal = new Plus();
        int result = cal.calculate(exp, "\\+");
        System.out.println(result);

        exp = "8-2";
        cal = new Minus();
        result = cal.calculate(exp, "\\-");
        System.out.println(result);
    }

}

2.15 观察者模式（Observer）

当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化

模式结构

• 接口类是 Observer；
• Observer1 和 Observer2 是实现于 Observer 的类，当 Observer 变化时，Observer1 和 Observer2 必然变化；
• 接口 Subject ；
• 抽象类 AbstractSubject 实现 Subject；
• MySubject 继承 AbstractSubject，其中的 operation方法 随着加入的Observer实现类不同而改变；

场景
比如我们关注了n个博客，可以关注到它们的更新信息

设计思路

• 接口 User ；
• Avatar1 和 Avatar2 是实现于 AbstractUser 的类；
• 接口类是 ProgramGroup；
• 抽象类 AbstractProgram 实现 ProgramGroup；
• Program 继承 AbstractProgram，其中的 operation 方法 随着加入的 User 实现类不同而改变；

public interface User {
    public void update();
}

public class Avatar1 implements User{
    @Override
    public void update() {
        System.out.println("Avatar1 has received.");
    }
}

public class Avatar2 implements User{
    @Override
    public void update() {
        System.out.println("Avatar2 has received.");
    }
}

public interface ProgramGroup {
    /*增加观察者*/
    public void add(User user);

    /*删除观察者*/
    public void del(User user);

    /*通知所有的观察者*/
    public void notifyObservers();

    /*自身的操作*/
    public void operation();
}

public abstract class AbstractProgram implements ProgramGroup{
    private Vector<User> vector = new Vector<User>();
    @Override
    public void add(User user) {
        vector.add(user);
    }

    @Override
    public void del(User user) {
        vector.remove(user);
    }

    @Override
    public void notifyObservers() {
        Enumeration<User> enumo = vector.elements();
        while(enumo.hasMoreElements()){
            enumo.nextElement().update();
        }
    }
}

public class Program extends AbstractProgram{
    @Override
    public void operation() {
        System.out.println("update self!");
        notifyObservers();
    }
}

public class Test {
    public static void main(String[] args) {
        AbstractProgram program = new Program();
        program.add(new Avatar1());
        program.add(new Avatar2());
        program.operation();
    }
}

2.16 迭代子模式（Iterator）

迭代器模式就是顺序访问聚集中的对象；

一是需要遍历的对象，即聚集对象；
二是迭代器对象，用于对聚集对象进行遍历访问。

public interface Iterator {
    //前移
    public Object previous();

    //后移
    public Object next();
    public boolean hasNext();

    //取得第一个元素
    public Object first();
}

public interface Collection {
    public Iterator iterator();

    /*取得集合元素*/
    public Object get(int i);

    /*取得集合大小*/
    public int size();
}

public class MyIterator implements Iterator{
    private Collection collection;
    private int pos = -1;

    public MyIterator(Collection collection){
        this.collection = collection;
    }

    @Override
    public Object previous() {
        if(pos > 0){
            pos--;
        }
        return collection.get(pos);
    }
    @Override
    public Object next() {
        if(pos<collection.size()-1){
            pos++;
        }
        return collection.get(pos);
    }
    @Override
    public boolean hasNext() {
        if(pos<collection.size()-1){
            return true;
        }else{
            return false;
        }
    }
    @Override
    public Object first() {
        pos = 0;
        return collection.get(pos);
    }
}

public class MyCollection implements Collection{
    public String string[] = {"A","B","C","D","E"};
    @Override
    public Iterator iterator() {
        return new MyIterator(this);
    }

    @Override
    public Object get(int i) {
        return string[i];
    }

    @Override
    public int size() {
        return string.length;
    }
}

public class Test {
    public static void main(String[] args) {
        Collection collection = new MyCollection();
        Iterator it = collection.iterator();

        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

2.17 责任链模式（Chain of Responsibility）

有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。

模式结构

• Abstracthandler 类提供了get 和set 方法
• MyHandle 类是核心，设置和修改引用对象，实例化后生成一系列相互持有的对象，构成一条链。

public interface Handler {
    public void operator();
}

public abstract class AbstractHandler {

    private Handler handler;

    public Handler getHandler() {
        return handler;
    }

    public void setHandler(Handler handler) {
        this.handler = handler;
    }

}

public class MyHandler extends AbstractHandler implements Handler {

    private String name;

    public MyHandler(String name) {
        this.name = name;
    }

    @Override
    public void operator() {
        System.out.println(name+"deal!");
        if(getHandler()!=null){
            getHandler().operator();
        }
    }
}

public class Test {

    public static void main(String[] args) {
        MyHandler h1 = new MyHandler("h1");
        MyHandler h2 = new MyHandler("h2");
        MyHandler h3 = new MyHandler("h3");

        h1.setHandler(h2);
        h2.setHandler(h3);

        h1.operator();
    }
}

2.18 命令模式（Command）

每个类相互解耦，任何一方都不用去依赖其他人，只需要做好自己的事儿就行

模式结构

• Invoker类 是调用者
• Receiver类 是被调用者
• Command 接口
• MyCommand 是命令，实现了Command 接口，持有接收对象

背景
司令员下令让士兵去干件事情，从整个事情的角度来考虑，司令员的作用是，发出口令，口令经过传递，传到了士兵耳朵里，士兵去执行。司令员要的是结果，不会去关注到底士兵是怎么实现的。

设计思路

• Command 接口
• MyCommand 是命令，实现了Command 接口，持有接收对象
• Soldier 是士兵
• Commander是司令员
  

public interface Command {
    public void exe();
}

public class MyCommand implements Command{
    private Soldier receiver;

    public MyCommand(Soldier receiver){
        this.receiver=receiver;
    }

    @Override
    public void exe() {
        receiver.action();
    }
}

public class Soldier {
    public void action(){
        System.out.println("Command received.");
    }
}

public class Commander {
    private Command command;

    public Commander(Command command){
        this.command=command;
    }

    public void action(){
        command.exe();
    }
}

2.19 备忘录模式（Memento）

主要目的
保存一个对象的某个状态，以便在适当的时候恢复对象

背景
假设有原始类A，A 中有各种属性，A 可以决定需要备份的属性，备忘录类B 是用来存储A 的一些内部状态，类C 呢，就是一个用来存储备忘录的，且只能存储，不能修改等操作。

结构

• Original 类是原始类，里面有需要保存的属性value 及创建一个备忘录类，用来保存 value值；
• Memento 类是备忘录类；
• Storage 类是存储备忘录的类，持有 Memento 类的实例，该模式很好理解。

public class Memento {

    private String value;

    public Memento(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}

public class Storage {

    private Memento memento;

    public Storage(Memento memento) {
        this.memento = memento;
    }

    public Memento getMemento() {
        return memento;
    }

    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}

public class Original {
    private String value;

    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }
    public Original(String value) {
        this.value = value;
    }
    public Memento createMemento(){
        return new Memento(value);
    }

    public void restoreMemento(Memento memento){
        this.value = memento.getValue();
    }
}

public class Test {

    public static void main(String[] args) {

        // 创建原始类
        Original origi = new Original("egg");

        // 创建备忘录
        Storage storage = new Storage(origi.createMemento());

        // 修改原始类的状态
        System.out.println("初始化状态为：" + origi.getValue());
        origi.setValue("niu");
        System.out.println("修改后的状态为：" + origi.getValue());

        // 回复原始类的状态
        origi.restoreMemento(storage.getMemento());
        System.out.println("恢复后的状态为：" + origi.getValue());
    }
}

2.20 状态模式（State）

核心思想：
当对象的状态改变时，同时改变其行为

背景
在QQ中，有几种状态，在线、隐身、忙碌等，每个状态对应不同的操作，而且你的好友也能看到你的状态

结构

• State 类是个状态类
• Context 类实现切换

public class State {

    private String value;

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public void method1(){
        System.out.println("execute the first opt!");
    }

    public void method2(){
        System.out.println("execute the second opt!");
    }
}

public class Context {

    private State state;

    public Context(State state) {
        this.state = state;
    }

    public State getState() {
        return state;
    }

    public void setState(State state) {
        this.state = state;
    }

    public void method() {
        if (state.getValue().equals("online")) {
            state.method1();
        } else if (state.getValue().equals("offline"))
            state.method2();
    }
}

public class Test {
    public static void main(String[] args) {
        State state = new State();
        Context context = new Context(state);

        //设置第一种状态
        state.setValue("online");
        context.method();

        //设置第二种状态
        state.setValue("offline");
        context.method();
    }
}

2.21 访问者模式（Visitor）

优缺点：

• 优点是增加操作很容易，因为增加操作意味着增加新的访问者。访问者模式将有关行为集中到一个访问者对象中，其改变不影响系统数据结构。
• 缺点就是增加新的数据结构很困难。

简单来说，访问者模式就是一种分离对象数据结构与行为的方法，通过这种分离，可达到为一个被访问者动态添加新的操作而无需做其它的修改的效果。

结构

• 接口Visitor
• MyVisitor类实现接口Visitor，其中有visit方法
• 接口Subject，accept 方法，接受将要访问它的对象，getSubject()获取将要被访问的属性
• MySubject类实现接口Subject，其中accept 方法导入参数为Visitor类，调用其中的visit方法

public interface Visitor {
    public void visit(Subject sub);
}

public class MyVisitor implements Visitor {

    @Override
    public void visit(Subject sub) {
        System.out.println("visit the subject："+sub.getSubject());
    }
}

public interface Subject {
    public void accept(Visitor visitor);
    public String getSubject();
}

public class MySubject implements Subject {

    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    @Override
    public String getSubject() {
        return "love";
    }
}

public class Test {
    public static void main(String[] args) {
        Visitor visitor = new MyVisitor();
        Subject sub = new MySubject();
        sub.accept(visitor);
    }
}

2.22 中介者模式（Mediator）

降低类类之间的耦合的，因为如果类类之间有依赖关系的话，不利于功能的拓展和维护，因为只要修改一个对象，其它关联的对象都得进行修改。
如果使用中介者模式，只需关心和Mediator 类的关系，具体类类之间的关系及调度交给Mediator 就行。

结构

• User 抽象类，其中在实现方法中传入 Mediator 类对象
• User1 和User2 继承 User
• 引入了 Mediator类，提供统一接口
• MyMediator 为其实现类，里面持有 User1 和User2 的实例，用来实现对User1 和User2 的控制

public abstract class User {

    private Mediator mediator;

    public Mediator getMediator(){
        return mediator;
    }
    public User(Mediator mediator) {
        this.mediator = mediator;
    }

    public abstract void work();

}

public class User1 extends User {

    public User1(Mediator mediator){
        super(mediator);
    }

    @Override
    public void work() {
        System.out.println("user1 exe!");
    }
}

public class User2 extends User {

    public User2(Mediator mediator){
        super(mediator);
    }

    @Override
    public void work() {
        System.out.println("user2 exe!");
    }
}

public interface Mediator {
    public void createMediator();
    public void workAll();
}

public class MyMediator implements Mediator {

    private User user1;
    private User user2;

    public User getUser1() {
        return user1;
    }

    public User getUser2() {
        return user2;
    }

    @Override
    public void createMediator() {
        user1 = new User1(this);
        user2 = new User2(this);
    }

    @Override
    public void workAll() {
        user1.work();
        user2.work();
    }
}

2.23 解释器模式（Interpreter）

应用的少，主要应用在 OOP 开发中的编译器的开发

public interface Expression {
    public int interpret(Context context);
}

public class Context {

    private int num1;
    private int num2;

    public Context(int num1, int num2) {
        this.num1 = num1;
        this.num2 = num2;
    }

    public int getNum1() {
        return num1;
    }
    public void setNum1(int num1) {
        this.num1 = num1;
    }
    public int getNum2() {
        return num2;
    }
    public void setNum2(int num2) {
        this.num2 = num2;
    }


}

public class Minus implements Expression {

    @Override
    public int interpret(Context context) {
        return context.getNum1()-context.getNum2();
    }
}

public class Plus implements Expression {

    @Override
    public int interpret(Context context) {
        return context.getNum1()+context.getNum2();
    }
}

public class Test {
    public static void main(String[] args) {

        // 计算 9+2-8 的值
        int result = new Minus().interpret((new Context(new Plus()
                .interpret(new Context(9, 2)), 8)));
        System.out.println(result);
    }
}