设计模式-原型模式

原型模式：使用原型实例指定待创建对象的类型，并且通过复制这个原型来创建新的对象。

由于在软件系统中经常会遇到需要创建多个相同或者相似对象的情况，因此原型模式在软件开发工具中具有较高的效率。

使用环境：

• 创建新对象成本较大。
• 系统要保存对象的状态，而对象的状态变化很少。

优点：

• 当创建新对象实例较为复杂时，使用原型模式可以简化对象的创建过程。通过复制一个已有实例可以提供新实例的创建效率。
• 扩展性好，原型模式中提供了抽象原型类，可以针对抽象原型类进行编程。

缺点：

• 需要为每一个类配备一个克隆方法。
• 实现深克隆需要编写较为复杂的代码。

浅克隆和深克隆

浅拷贝：

当原型对象被复制时，只复制它本身和其中包含的值类型的成员变量，而引用类型的成员变量并没有复制。

• 值类型：int、double、byte等基本数据类型
• 引用类型：类、接口、数组

深拷贝：

当原型对象被复制时，除了本身被复制外，对象所包含的所有成员变量也将被复制。

克隆实现方案

通用方法

抽象类：

public abstract class Prototype {

    /**
     * 通用克隆
     * @return
     */
    @Override
    public abstract Prototype clone();
}

普通类：

public class ConcretePrototype extends Prototype{

    private String str;

    public void setStr(String str) {
        this.str = str;
    }

    public String getStr() {
        return this.str;
    }


    @Override
    public Prototype clone() {
        ConcretePrototype concretePrototype = new ConcretePrototype();
        concretePrototype.setStr(this.str);
        return concretePrototype;
    }
}

Clone()方法和Cloneable接口

public class ClonePrototype implements Cloneable{

    private String str;

    public void setStr(String str) {
        this.str = str;
    }

    public String getStr() {
        return this.str;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

案例

形状抽象类：

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

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

形状类：

public class Rectangle extends Shape {

    Rectangle() {
        this.type = "Rectangle";
    }

    @Override
    void draw() {
        System.out.println("长方形的draw()方法");
    }
}

public class Square extends Shape {

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

    @Override
    void draw() {
        System.out.println("正方形的draw()方法");
    }
    
}

public class Circle extends Shape{

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

    @Override
    public void draw() {
        System.out.println("圈的draw()方法");
    }

}

形状的缓存：

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

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

案例：

public class PrototypePatternDemo {
    public static void main(String[] args) {
        ShapeCache.loadCache();

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

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

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

Shape : Circle
圈的draw()方法
Shape : Square
正方形的draw()方法
Shape : Rectangle
长方形的draw()方法

参考

设计模式入门实践 (opens new window)