【玩转23种Java设计模式】创建型模式篇：原型模式

软件设计模式（Design pattern），又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

汇总目录链接：【玩转23种Java设计模式】学习目录汇总整理

一、简介

  将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例。
  这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。

二、实例

1、Shape

实现了Cloneable接口的抽象类。

public abstract class Shape implements Cloneable {

    private String id;
    protected String type;

    abstract void buy();

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

2、Apple

public class Apple extends Shape {

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

    @Override
    public void buy() {
        System.out.println("buy() method: Apple");
    }
}

3、Banana

public class Banana extends Shape {

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

    @Override
    public void buy() {
        System.out.println("buy() method: Banana");
    }
}

4、Orange

public class Orange extends Shape {

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

    @Override
    public void buy() {
        System.out.println("buy() method: Orange");
    }
}

5、ShapeCache

public class ShapeCache {

    private static HashMap<String, Shape> shapeMap = new HashMap<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() {
        Apple apple = new Apple();
        apple.setId("1");
        shapeMap.put(apple.getId(),apple);

        Banana banana = new Banana();
        banana.setId("2");
        shapeMap.put(banana.getId(),banana);

        Orange orange = new Orange();
        orange.setId("3");
        shapeMap.put(orange.getId(),orange);
    }
}

6、测试类

public class Main {
    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());
    }
}

控制台输出：

Shape : Apple
Shape : Banana
Shape : Orange

三、总结

1、优点

• 性能提高。它是在运行时操作对象，操作的是内存中的二进制流，在创建大对象时，相比 new 一个对象，性能优势明显。
• 逃避构造函数的约束。直接在内存中拷贝，构造函数是不会执行的。

2、缺点

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

3、应用场景

• 资源优化场景，包括数据、硬件资源等。
• 性能和安全要求的场景。
• 一个对象多个修改者的场景。 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。