- N +

设计模式之原型模式

设计模式之原型模式原标题:设计模式之原型模式

导读:

什么是原型模式?创建型模式中一个比较特殊的模式-原型模式,这个模式呢,有个最大的特点是克隆一个现有的对象,这个克隆的结果有2种,一种是是浅复制,另一种是深复制,这里我们也会探讨...

文章目录 [+]

什么是原型模式

创建型模式中一个比较特殊的模式-原型模式,这个模式呢,有个最大的特点是克隆一个现有的对象,这个克隆的结果有2种,一种是

是浅复制,另一种是深复制,这里我们也会探讨下深复制和浅复制的原理,这样可能更方便大家理解这个原型模式的使用。我们都知道,创建型模式一般是

用来创建一个新的对象,然后我们使用这个对象完成一些对象的操作,我们通过原型模式可以快速的创建一个对象而不需要提供专门的new()操作就可以快

速完成对象的创建,这无疑是一种非常有效的方式,快速的创建一个新的对象。


原型模式中的拷贝分为"浅复制"和"深复制":
浅复制: 对值类型的成员变量进行值的复制,对引用类型的成员变量只复制引用,不复制引用的对象.
深复制: 对值类型的成员变量进行值的复制,对引用类型的成员变量也进行引用对象的复制.

原型模式意图

由于有些时候,需要在运行时指定对象时哪个类的实例,此时用工厂模式就有些力不从心了。通过原型模式就可以通过拷贝函数clone一个原有的对象,给现在的对象使用,从而创建更多的同类型的对象。

原型模式角色

Prototype 原型接口,定义原型的结构。

ConcretePrototype 原型的具体实现。

Client 使用类,创建一个原型,创建一个引用,可以随意指定要引用的实现类。

PrototypeManager 原型的管理器,里面含有一个Map,用来保存原型的实例对象。

原型模式角色

1 当需要在运行时指定对象的实现类时。

2 当一个类的实例只能有集中状态的一种时。

简单原型模式

interface Prototype {
    public Object clone();
}

class ConcretePrototype1 implements Prototype {
    public Object clone() {
        Prototype prototype = new ConcretePrototype1();
        return prototype;
    }
}

class ConcretePrototype2 implements Prototype {
    public Object clone() {
        Prototype prototype = new ConcretePrototype2();
        return prototype;
    }
}

public class Client {
    public static void main(String[] args) {
        Prototype p1 = new ConcretePrototype1();
        System.out.println("p1 " + p1);

        Prototype p2 = new ConcretePrototype2();
        System.out.println("p2 " + p2);

        Prototype prototype = (Prototype) p1.clone();
        System.out.println("prototype " + prototype);
        prototype = (Prototype) p2.clone();
        System.out.println("prototype " + prototype);
    }
}

登记模式的原型模式

/**
 * 原型的接口
 * 
 * @author 
 */
interface Prototype {
    public Prototype clone();
}

/**
 * 具体的实现类1
 * 
 * @author 
 * 
 */
class ConcretePrototype1 implements Prototype {
    public Prototype clone() {
        Prototype prototype = new ConcretePrototype1();
        return prototype;
    }
}

/**
 * 具体的实现类2
 * 
 * @author 
 * 
 */
class ConcretePrototype2 implements Prototype {
    public Prototype clone() {
        Prototype prototype = new ConcretePrototype2();
        return prototype;
    }
}

/**
 * 原型的管理器
 * 
 * @author 
 * 
 */
class PrototypeManager {
    /**
     * 用于保存原型的实例
     */
    private static Map<String, Prototype> map = new HashMap<String, Prototype>();

    /**
     * 静态方法创建构造函数,避免外部类调用
     */
    private PrototypeManager() {
    }

    /**
     * 添加原型
     * 
     * @param protoName
     *            原型的名字
     * @param prototype
     *            原型的实例
     */
    public synchronized static void setPrototype(String protoName,
            Prototype prototype) {
        map.put(protoName, prototype);
    }

    /**
     * 获得原型
     * 
     * @param protoName
     *            原型的名字
     * @return 返回原型的实例
     * @throws Exception
     *             如果找不到,则跑出找不到异常
     */
    public synchronized static Prototype getPrototype(String protoName)
            throws Exception {
        Prototype prototype = map.get(protoName);
        if (prototype == null) {
            throw new Exception("no " + protoName + " in Manager");
        }
        return prototype;
    }

    /**
     * 从管理器中删除原型的实例
     * 
     * @param protoName
     *            原型的名字
     */
    public synchronized static void removedPrototype(String protoName) {
        map.remove(protoName);
    }
}

/**
 * 原型的使用者
 * 
 * @author 
 * 
 */
public class Client {
    public static void main(String[] args) {
        try {
            /**
             * 创建一种原型的实现,放入管理器中
             */
            Prototype p1 = new ConcretePrototype1();
            System.out.println("p1 " + p1);
            PrototypeManager.setPrototype("MyPrototype", p1);

            Prototype prototype1 = PrototypeManager.getPrototype("MyPrototype")
                    .clone();
            System.out.println("prototype1 " + prototype1);
            /**
             * 切换成另一种原型的实现,修改管理器中的对象
             */
            Prototype p2 = new ConcretePrototype1();
            System.out.println("p2 " + p2);
            PrototypeManager.setPrototype("p1", p2);

            Prototype prototype2 = PrototypeManager.getPrototype("MyPrototype")
                    .clone();
            System.out.println("prototype2 " + prototype2);
            /**
             * 注销该原型实现,对象使用后,观察情况
             */
            PrototypeManager.removedPrototype("MyPrototype");

            Prototype prototype3 = PrototypeManager.getPrototype("MyPrototype")
                    .clone();
            System.out.println("prototype3 " + prototype3);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


本文标题:设计模式之原型模式
本文链接:http://www.kyjszj.com/wdzl/18.html
作者授权:除特别说明外,本文由 开源技术之家 原创编译并授权 开源技术之家 刊载发布。
版权声明:本文不使用任何协议授权,您可以任何形式自由转载或使用。

有好的文章希望我们帮助分享和推广,猛戳这里我要投稿

返回列表
上一篇:
下一篇:

发表评论中国互联网举报中心

快捷回复:

    评论列表 (暂无评论,共631人参与)参与讨论

    还没有评论,来说两句吧...