设计模式：创建型模式

设计模式 - 可复用的面向对象软件元素

设计模式：结构型模式

设计模式：行为型模式

23种设计模式的全部示例代码可以到我的github下载

二、创建型模式

2.1 单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

1、单例类只能有一个实例。

2、单例类必须自己创建自己的唯一实例。

3、单例类必须给所有其他对象提供这一实例。

2.1.1 介绍

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建与销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

应用实例：

1、一个党只能有一个主席。

2、Windows是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。

3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。

2、避免对资源的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

1、要求生产唯一序列号。

2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。

3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

注意事项：getInstance()方法中需要使用同步锁synchronized (Singleton.class)，防止多线程同时进入造成 instance 被多次实例化。

2.1.2 实现

package designpatterns.singleton;

/**
* 懒汉式，线程不安全
*
* 这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，
* 所以严格意义上它并不算单例模式。这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。
*
* @author exuejwa
*
*/
public class Singleton1 {
private static Singleton1 instance;

private Singleton1() {
}

public static Singleton1 getInstance() {
if (instance == null) {
instance = new Singleton1();
}
return instance;
}
}

package designpatterns.singleton;

/**
* 懒汉式，线程安全
*
* 这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
* 优点：第一次调用才初始化，避免内存浪费。
* 缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。getInstance()的性能对应用程序不是很关键（该方法使用不太频繁）。
*
* @author exuejwa
*
*/
public class Singleton2 {
private static Singleton2 instance;

private Singleton2() {
}

public static synchronized Singleton2 getInstance() {
if (instance == null) {
instance = new Singleton2();
}
return instance;
}

}

package designpatterns.singleton;

/**
* 饿汉式
*
* 这种方式比较常用，但容易产生垃圾对象。
* 优点：没有加锁，执行效率会提高。
* 缺点：类加载时就初始化，浪费内存。
* 它基于 classloder机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，
* 在单例模式中大多数都是调用 getInstance方法，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，
* 这时候初始化instance显然没有达到lazy loading的效果。
*
* @author exuejwa
*
*/
public class Singleton３ {
private static Singleton３ instance = new Singleton３();

private Singleton３() {
}

public static Singleton３ getInstance() {
return instance;
}
}

package designpatterns.singleton;

/**
* 双检锁/双重校验锁（DCL，即 double-checked locking）
*
* 这种方式采用双锁机制，安全且在多线程情况下能保持高性能。getInstance() 的性能对应用程序很关键。
*
* @author exuejwa
*
*/
public class Singleton4 {
private volatile static Singleton4 singleton;

private Singleton4() {
}

public static Singleton4 getSingleton() {
if (singleton == null) {
synchronized (Singleton4.class) {
if (singleton == null) {
singleton = new Singleton4();
}
}
}
return singleton;
}
}

package designpatterns.singleton;

/**
* 登记式/静态内部类
*
* 这种方式能达到双检锁方式一样的功效，但实现更简单。
* 对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。
* 这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。
* 这种方式同样利用了 classloder 机制来保证初始化 instance 时只有一个线程，它跟第 3种方式不同的是：
* 第3种方式只要Singleton类被装载了，那么instance就会被实例化（没有达到 lazy loading效果），
* 因为 SingletonHolder类没有被主动使用，只有显示通过调用 getInstance 方法时，才会显示装载 SingletonHolder类，
* 从而实例化instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在
* Singleton类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化
* instance显然是不合适的。这个时候，这种方式相比第 3 种方式就显得很合理。
*
* @author exuejwa
*
*/
public class Singleton５ {
private static class SingletonHolder {
private static final Singleton５ INSTANCE = new Singleton５();
}

private Singleton５() {
}

public static final Singleton５ getInstance() {
return SingletonHolder.INSTANCE;
}
}

package designpatterns.singleton;

/**
* 枚举
*
* 这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。
* 防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉
* 生疏，在实际工作中，也很少用。不能通过 reflection attack来调用私有构造方法。
*
* @author exuejwa
*
*/
public enum Singleton6 {
INSTANCE;
public void whateverMethod() {
System.out.println("hello world");
}
}

经验之谈：一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。只有在要明确实现 lazy loading效果时，才会使用第 5 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。如果有其他特殊的需求，可以考虑使用第 4种双检锁方式。

2.2 工厂模式

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

2.2.1 介绍

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

主要解决：主要解决接口选择的问题。

如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

关键代码：创建过程在其子类执行。

应用实例：

1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。

2、Hibernate换数据库只需换方言和驱动就可以。

优点：

1、一个调用者想创建一个对象，只要知道其名称就可以了。

2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。

3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

使用场景：

1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。

2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。

3、设计一个连接服务器的框架，需要三个协议，”POP3”、”IMAP”、”HTTP”，可以把这三个作为产品类，共同实现一个接口。

注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

2.2.2 实现

package designpatterns.factory;

/**
* 步骤 1 创建一个接口
*
* @author exuejwa
*
*/
public interface Shape {
void draw();
}

package designpatterns.factory;

/**
* 步骤 2 创建实现接口的实体类。
*
* @author exuejwa
*
*/
public class Rectangle implements Shape {

public void draw() {
System.out.println("Inside Rectangle::draw() method.");

}
}

package designpatterns.factory;

/**
* 步骤 2　创建实现接口的实体类。
*
* @author exuejwa
*
*/
public class Square implements Shape {

public void draw() {
System.out.println("Inside Square::draw() method.");

}
}

package designpatterns.factory;

/**
* 步骤 2　创建实现接口的实体类。
*
* @author exuejwa
*
*/
public class Circle implements Shape {

public void draw() {
System.out.println("Inside Circle::draw() method.");

}
}

package designpatterns.factory;

/**
* 步骤 3 创建一个工厂，生成基于给定信息的实体类的对象。
*
* @author exuejwa
*
*/
public class ShapeFactory {

// 使用 getShape 方法获取形状类型的对象
public Shape getShape(String shapeType) {
if (shapeType == null) {
return null;
}
if (shapeType.equalsIgnoreCase("CIRCLE")) {
return new Circle();
} else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
return new Rectangle();
} else if (shapeType.equalsIgnoreCase("SQUARE")) {
return new Square();
}
return null;
}
}

package designpatterns.factory;

/**
* 步骤 4 使用该工厂，通过传递类型信息来获取实体类的对象。
*
* @author exuejwa
*
*/
public class FactoryPatternDemo {
public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();

// 获取 Circle 的对象，并调用它的 draw 方法
Shape shape1 = shapeFactory.getShape("CIRCLE");

// 调用 Circle 的 draw 方法
shape1.draw();

// 获取 Rectangle 的对象，并调用它的 draw 方法
Shape shape2 = shapeFactory.getShape("RECTANGLE");

// 调用 Rectangle 的 draw 方法
shape2.draw();

// 获取 Square 的对象，并调用它的 draw 方法
Shape shape3 = shapeFactory.getShape("SQUARE");

// 调用 Square 的 draw 方法
shape3.draw();
}
}

2.3 抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

2.3.1 介绍

意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 主要解决：主要解决接口选择的问题。

何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。 如何解决：在一个产品族里面，定义多个产品。

关键代码：在一个工厂里聚合多个同类产品。

应用实例：工作了，为了参加一些聚会，肯定有两套或多套衣服吧，比如说有商务装（成套，一系列具体产品）、时尚装（成套，一系列具体产品），甚至对于一个家庭来说，可能有商务女装、商务男装、时尚女装、时尚男装，这些也都是成套的，即一系列具体产品。假设一种情况（现实中是不存在的，要不然，没法进入共产主义了，但有利于说明抽象工厂模式），在您的家中，某一个衣柜（具体工厂）只能存放某一种这样的衣服（成套，一系列具体产品），每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 OO的思想去理解，所有的衣柜（具体工厂）都是衣柜类的（抽象工厂）某一个，而每一件成套的衣服又包括具体的上衣（某一具体产品），裤子（某一具体产品），这些具体的上衣其实也都是上衣（抽象产品），具体的裤子也都是裤子（另一个抽象产品）。

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

注意事项：产品族难扩展，产品等级易扩展。

2.3.2 实现

我们将创建 Shape 和 Color 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义工厂类 ShapeFactory 和 ColorFactory，这两个工厂类都是扩展了AbstractFactory。然后创建一个工厂创造器/生成器类 FactoryProducer。

AbstractFactoryPatternDemo，我们的演示类使用FactoryProducer 来获取 AbstractFactory对象。它将向AbstractFactory传递形状信息Shape（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。同时它还向AbstractFactory传递颜色信息 Color（RED / GREEN / BLUE），以便获取它所需对象的类型。

package designpatterns.abstractfactorypattern;

/**
* 步骤 1 为形状创建一个接口。
*
* @author exuejwa
*
*/
public interface Shape {
void draw();
}

package designpatterns.abstractfactorypattern;

/**
* 步骤 2 创建实现接口的实体类。
*
* @author exuejwa
*
*/
public class Rectangle implements Shape {

public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}

package designpatterns.abstractfactorypattern;

/**
* 步骤 2 创建实现接口的实体类。
*
* @author exuejwa
*
*/
public class Square implements Shape {

public void draw() {
System.out.println("Inside Square::draw() method.");
}
}

package designpatterns.abstractfactorypattern;

/**
* 步骤 3 为颜色创建一个接口。
*
* @author exuejwa
*
*/
public interface Color {
void fill();
}

package designpatterns.abstractfactorypattern;

/**
* 步骤 4 创建实现接口的实体类。
*
* @author exuejwa
*
*/
public class Green implements Color {

public void fill() {
System.out.println("Inside Green::fill() method.");
}
}

package designpatterns.abstractfactorypattern;

/**
* 步骤 4 创建实现接口的实体类。
*
* @author exuejwa
*
*/
public class Red implements Color {

public void fill() {
System.out.println("Inside Red::fill() method.");
}
}

package designpatterns.abstractfactorypattern;

/**
* 步骤 5 为 Color 和 Shape 对象创建抽象类来获取工厂。
*
* @author exuejwa
*
*/
public abstract class AbstractFactory {

abstract Color getColor(String color);

abstract Shape getShape(String shape);
}

package designpatterns.abstractfactorypattern;

/**
* 步骤 6 创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象。
*
* @author exuejwa
*
*/
public class ShapeFactory extends AbstractFactory {

@Override
public Shape getShape(String shapeType) {
if (shapeType == null) {
return null;
}
if (shapeType.equalsIgnoreCase("RECTANGLE")) {
return new Rectangle();
} else if (shapeType.equalsIgnoreCase("SQUARE")) {
return new Square();
}
return null;
}

@Override
Color getColor(String color) {
return null;
}
}

package designpatterns.abstractfactorypattern;

/**
* 步骤 6 创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象。
*
* @author exuejwa
*
*/
public class ColorFactory extends AbstractFactory {

@Override
public Shape getShape(String shapeType) {
return null;
}

@Override
Color getColor(String color) {
if (color == null) {
return null;
}
if (color.equalsIgnoreCase("RED")) {
return new Red();
} else if (color.equalsIgnoreCase("GREEN")) {
return new Green();
}
return null;
}
}

package designpatterns.abstractfactorypattern;

/**
* 步骤 7 创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂。
*
* @author exuejwa
*
*/
public class FactoryProducer {
public static AbstractFactory getFactory(String choice) {
if (choice.equalsIgnoreCase("SHAPE")) {
return new ShapeFactory();
} else if (choice.equalsIgnoreCase("COLOR")) {
return new ColorFactory();
}
return null;
}
}

package designpatterns.abstractfactorypattern;

/**
* 步骤 8 使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。
*
* @author exuejwa
*
*/
public class AbstractFactoryPatternDemo {
public static void main(String[] args) {

// 获取形状工厂
AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");

// 获取形状为 Rectangle 的对象
Shape shape2 = shapeFactory.getShape("RECTANGLE");

// 调用 Rectangle 的 draw 方法
shape2.draw();

// 获取形状为 Square 的对象
Shape shape3 = shapeFactory.getShape("SQUARE");

// 调用 Square 的 draw 方法
shape3.draw();

// 获取颜色工厂
AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");

// 获取颜色为 Red 的对象
Color color1 = colorFactory.getColor("RED");

// 调用 Red 的 fill 方法
color1.fill();

// 获取颜色为 Green 的对象
Color color2 = colorFactory.getColor("Green");

// 调用 Green 的 fill 方法
color2.fill();
}
}

2.4 建造者模式

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

2.4.1 介绍

意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

主要解决：主要解决在软件系统中，有时候面临着”一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

何时使用：一些基本部件不会变，而其组合经常变化的时候。 如何解决：将变与不变分离开。

关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

应用实例：

1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的”套餐”。

2、JAVA 中的StringBuilder。

优点：

1、建造者独立，易扩展。

2、便于控制细节风险。

缺点：

1、产品必须有共同点，范围有限制。

2、如内部变化复杂，会有很多的建造类。

使用场景：

1、需要生成的对象具有复杂的内部结构。

2、需要生成的对象内部属性本身相互依赖。

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

2.4.2 实现

我们假设一个快餐店的商业案例，其中，一个典型的套餐可以是一个汉堡（Burger）和一杯冷饮（Cold drink）。汉堡（Burger）可以是素食汉堡（Veg Burger）或鸡肉汉堡（Chicken Burger），它们是包在纸盒中。冷饮（Cold drink）可以是可口可乐（coke）或百事可乐（pepsi），它们是装在瓶子中。

我们将创建一个表示食物条目（比如汉堡和冷饮）的 Item 接口和实现 Item 接口的实体类，以及一个表示食物包装的 Packing 接口和实现 Packing 接口的实体类，汉堡是包在纸盒中，冷饮是装在瓶子中。

然后我们创建一个 Meal 类，带有 Item 的 ArrayList 和一个通过结合 Item 来创建不同类型的 Meal 对象的 MealBuilder。BuilderPatternDemo，我们的演示类使用 MealBuilder 来创建一个 Meal。

package designpatterns.builderpattern;

/**
* 步骤 1 创建一个表示食物条目和食物包装的接口。
*
* @author exuejwa
*
*/
public interface Item {
public String name();

public Packing packing();

public float price();
}

package designpatterns.builderpattern;

/**
* 步骤 1 创建一个表示食物条目和食物包装的接口。
*
* @author exuejwa
*
*/
public interface Packing {
public String pack();
}

package designpatterns.builderpattern;

/**
* 步骤 2 创建实现 Packing 接口的实体类。
*
* @author exuejwa
*
*/
public class Wrapper implements Packing {

public String pack() {
return "Wrapper";
}
}

package designpatterns.builderpattern;

/**
* 步骤 2 创建实现 Packing 接口的实体类。
*
* @author exuejwa
*
*/
public class Bottle implements Packing {

public String pack() {
return "Bottle";
}
}

package designpatterns.builderpattern;

/**
* 步骤 3 创建实现 Item 接口的抽象类，该类提供了默认的功能。
*
* @author exuejwa
*
*/
public abstract class Burger implements Item {

public Packing packing() {
return new Wrapper();
}

public abstract float price();
}

package designpatterns.builderpattern;

/**
* 步骤 3 创建实现 Item 接口的抽象类，该类提供了默认的功能。
*
* @author exuejwa
*
*/
public abstract class ColdDrink implements Item {

public Packing packing() {
return new Bottle();
}

public abstract float price();
}

package designpatterns.builderpattern;

/**
* 步骤 4 创建扩展了 Burger 和 ColdDrink 的实体类。
*
* @author exuejwa
*
*/
public class VegBurger extends Burger {

@Override
public float price() {
return 25.0f;
}

public String name() {
return "Veg Burger";
}
}

package designpatterns.builderpattern;

/**
* 步骤 4 创建扩展了 Burger 和 ColdDrink 的实体类。
*
* @author exuejwa
*
*/
public class ChickenBurger extends Burger {

@Override
public float price() {
return 50.5f;
}

public String name() {
return "Chicken Burger";
}
}

package designpatterns.builderpattern;

/**
* 步骤 4 创建扩展了 Burger 和 ColdDrink 的实体类。
*
* @author exuejwa
*
*/
public class Coke extends ColdDrink {

@Override
public float price() {
return 30.0f;
}

public String name() {
return "Coke";
}
}

package designpatterns.builderpattern;

/**
* 步骤 4 创建扩展了 Burger 和 ColdDrink 的实体类。
*
* @author exuejwa
*
*/
public class Pepsi extends ColdDrink {

@Override
public float price() {
return 35.0f;
}

public String name() {
return "Pepsi";
}
}

package designpatterns.builderpattern;

import java.util.ArrayList;
import java.util.List;

public class Meal {
private List<Item> items = new ArrayList<Item>();

public void addItem(Item item){
items.add(item);
}

public float getCost(){
float cost = 0.0f;
for (Item item : items) {
cost += item.price();
}
return cost;
}

public void showItems(){
for (Item item : items) {
System.out.print("Item : "+item.name());
System.out.print(", Packing : "+item.packing().pack());
System.out.println(", Price : "+item.price());
}
}
}

package designpatterns.builderpattern;

/**
* 步骤 6 创建一个 MealBuilder类，实际的 builder类负责创建 Meal对象。
*
* @author exuejwa
*
*/
public class MealBuilder {

public Meal prepareVegMeal() {
Meal meal = new Meal();
meal.addItem(new VegBurger());
meal.addItem(new Coke());
return meal;
}

public Meal prepareNonVegMeal() {
Meal meal = new Meal();
meal.addItem(new ChickenBurger());
meal.addItem(new Pepsi());
return meal;
}
}

package designpatterns.builderpattern;

/**
* 步骤 7 BuiderPatternDemo 使用 MealBuider 来演示建造者模式（Builder Pattern）。
*
* @author exuejwa
*
*/
public class BuilderPatternDemo {
public static void main(String[] args) {
MealBuilder mealBuilder = new MealBuilder();

Meal vegMeal = mealBuilder.prepareVegMeal();
System.out.println("Veg Meal");
vegMeal.showItems();
System.out.println("Total Cost: " + vegMeal.getCost());

Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
System.out.println("\n\nNon-Veg Meal");
nonVegMeal.showItems();
System.out.println("Total Cost: " + nonVegMeal.getCost());
}
}

2.5 原型模式

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

2.5.1 介绍

意图：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

主要解决：在运行期建立和删除原型。

何时使用：

1、当一个系统应该独立于它的产品创建，构成和表示时。

2、当要实例化的类是在运行时刻指定时，例如，通过动态装载。

3、为了避免创建一个与产品类层次平行的工厂类层次时。

4、当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

如何解决：利用已有的一个原型对象，快速地生成和原型对象一样的实例。

关键代码：

1、实现克隆操作，在 JAVA 继承Cloneable，重写 clone()，在 .NET 中可以使用 Object 类的 MemberwiseClone()方法来实现对象的浅拷贝或通过序列化的方式来实现深拷贝。

2、原型模式同样用于隔离类对象的使用者和具体类型（易变类）之间的耦合关系，它同样要求这些”易变类”拥有稳定的接口。

应用实例：

1、细胞分裂。

2、JAVA 中的 Object clone() 方法。

优点：

1、性能提高。

2、逃避构造函数的约束。

缺点：

1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。

2、必须实现 Cloneable 接口。

3、逃避构造函数的约束。

使用场景：

1、资源优化场景。

2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。

3、性能和安全要求的场景。

4、通过 new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。

5、一个对象多个修改者的场景。

6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。

7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。

注意事项：与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。

2.5.2 实现

我们将创建一个抽象类 Shape 和扩展了 Shape 类的实体类。下一步是定义类 ShapeCache，该类把 shape 对象存储在一个 Hashtable 中，并在请求的时候返回它们的克隆。PrototypPatternDemo，我们的演示类使用 ShapeCache 类来获取 Shape 对象。

package designpatterns.prototypepattern;

/**
* 步骤 1 创建一个实现了 Clonable 接口的抽象类。
*
* @author exuejwa
*
*/
public abstract class Shape implements Cloneable {

private String id;
protected String type;

abstract void draw();

public String getType() {
return type;
}

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

public Object clone() {
Object clone = null;
try {
clone = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return clone;
}
}

package designpatterns.prototypepattern;

/**
* 步骤 2 创建扩展了上面抽象类的实体类。
*
* @author exuejwa
*
*/
public class Rectangle extends Shape {

public Rectangle() {
type = "Rectangle";
}

@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}

package designpatterns.prototypepattern;

/**
* 步骤 2 创建扩展了上面抽象类的实体类。
*
* @author exuejwa
*
*/
public class Square extends Shape {

public Square() {
type = "Square";
}

@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}

package designpatterns.prototypepattern;

/**
* 步骤 2 创建扩展了上面抽象类的实体类。
*
* @author exuejwa
*
*/
public class Circle extends Shape {

public Circle() {
type = "Circle";
}

@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}

package designpatterns.prototypepattern;

import java.util.Hashtable;

/**
* 步骤 3 创建一个类，从数据库获取实体类，并把它们存储在一个 Hashtable 中。
*
* @author exuejwa
*
*/
public class ShapeCache {

private static Hashtable<String, Shape> shapeMap = new Hashtable<String, Shape>();

public static Shape getShape(String shapeId) {
Shape cachedShape = shapeMap.get(shapeId);
return (Shape) cachedShape.clone();
}

// 对每种形状都运行数据库查询，并创建该形状
// shapeMap.put(shapeKey, shape);
// 例如，我们要添加三种形状
public static void loadCache() {
Circle circle = new Circle();
circle.setId("1");
shapeMap.put(circle.getId(), circle);

Square square = new Square();
square.setId("2");
shapeMap.put(square.getId(), square);

Rectangle rectangle = new Rectangle();
rectangle.setId("3");
shapeMap.put(rectangle.getId(), rectangle);
}
}

package designpatterns.prototypepattern;

/**
* 步骤 4 PrototypePatternDemo使用 ShapeCache类来获取存储在 Hashtable中的形状的克隆。
*
* @author exuejwa
*
*/
public class PrototypePatternDemo {
public static void main(String[] args) {
ShapeCache.loadCache();

Shape clonedShape = (Shape) ShapeCache.getShape("1");
System.out.println("Shape : " + clonedShape.getType());

Shape clonedShape2 = (Shape) ShapeCache.getShape("2");
System.out.println("Shape : " + clonedShape2.getType());

Shape clonedShape3 = (Shape) ShapeCache.getShape("3");
System.out.println("Shape : " + clonedShape3.getType());
}
}

参考

本文部分内容翻译自http://www.avajava.com/tutorials/categories/design-patterns，部分内容收集自http://www.runoob.com/design-pattern/design-pattern-tutorial.html，部分内容收集自末尾参考中的资料。

Wiki Page for Design Patterns - 以一种非常通用的方式检查设计模式。

Java Programming/Design Patterns - 一篇关于设计模式的好文章。

The JavaTM Tutorials - 该 Java 教程是为那些想用 Java 编程语言创建应用程序的编程人员提供的实用指南。

JavaTM 2 SDK, Standard Edition - JavaTM 2 SDK, Standard Edition 的官网。

Java DesignPatterns - 关于设计模式的短文。