GOF23之原型模式Demo

最新推荐文章于 2024-10-03 12:37:09 发布
最新推荐文章于 2024-10-03 12:37:09 发布
阅读量383 收藏
点赞数
分类专栏： java 文章标签： 原型模式

原型模式是指用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象，主要用于对象的复制，它的核心是就是类图中的原型类Prototype。Prototype类需要具备以下两个条件：
实现Cloneable接口、重写Object类中的clone方法。
原型模式是一种比较简单的模式，也非常容易理解，实现一个接口，重写一个方法即完成了原型模式。在实际应用中，原型模式很少单独出现。经常与其他模式混用，他的原型类Prototype也常用抽象类来替代。
以克隆羊为例：
Sheep类

import java.io.Serializable;
import java.util.Date;
public class Sheep implements Cloneable,Serializable {
    private String sname;
    private Date birthday;


    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj = super.clone();  //直接调用object对象的clone()方法！
        return obj;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }


    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public Sheep(String sname, Date birthday) {
        super();
        this.sname = sname;
        this.birthday = birthday;
    }

    public Sheep() {}
}

Client测试类：

public class Client {
    public static void main(String[] args) throws Exception {
        Date date = new Date(12312321331L);
        Sheep s1 = new Sheep("我是一只羊",date);
        System.out.println(s1);
        System.out.println(s1.getSname());
        System.out.println(s1.getBirthday());

        Sheep s2 = (Sheep) s1.clone();
        s2.setSname("我是另一只羊");

        date.setTime(23432432423L);

        System.out.println(s1.getBirthday());
        System.out.println(s2);
        System.out.println(s2.getSname());
        System.out.println(s2.getBirthday());

    }
}

运行结果：
com.gujian.prototype.Sheep@6e1408
我是一只羊
Sat May 23 20:05:21 CST 1970
Tue Sep 29 13:00:32 CST 1970
com.gujian.prototype.Sheep@21b6d
我是另一只羊
Tue Sep 29 13:00:32 CST 1970
可以看出，s1的birthday属性变化会导致s2的也变化,这是一种浅复制

备注：深拷贝与浅拷贝问题中，会发生深拷贝的有java中的8中基本类型以及他们的封装类型，另外还有String类型。其余的都是浅拷贝。

如果要进行深复制，需要将属性也进行克隆。改造如下：

import java.util.Date;

//测试深复制
public class Sheep2 implements Cloneable {   
    private String sname;
    private Date birthday;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj = super.clone();  //直接调用object对象的clone()方法！

        //添加如下代码实现深复制(deep Clone)
        Sheep2 s = (Sheep2) obj;
        s.birthday = (Date) this.birthday.clone();  //把属性也进行克隆！

        return obj;
    }


    public String getSname() {
        return sname;
    }


    public void setSname(String sname) {
        this.sname = sname;
    }


    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public Sheep2(String sname, Date birthday) {
        super();
        this.sname = sname;
        this.birthday = birthday;
    }

    public Sheep2() {}
}

Client2 测试类：

public class Client2 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Date date = new Date(12312321331L);
        Sheep2 s1 = new Sheep2("我是一只羊",date);
        Sheep2 s2 = (Sheep2) s1.clone();   //实现深复制。s2对象的birthday是一个新对象！

        System.out.println(s1);
        System.out.println(s1.getSname());
        System.out.println(s1.getBirthday());

        date.setTime(23432432423L);

        System.out.println(s1.getBirthday());

        s2.setSname("我是另一只养");
        System.out.println(s2);
        System.out.println(s2.getSname());
        System.out.println(s2.getBirthday());
    }
}

运行结果：
com.gujian.prototype.Sheep2@e53108
我是一只羊
Sat May 23 20:05:21 CST 1970
Tue Sep 29 13:00:32 CST 1970
com.gujian.prototype.Sheep2@21b6d
我是另一只养
Sat May 23 20:05:21 CST 1970
可以看出s1对象的修改并没有影响到s2。

还可以使用使用序列化和反序列化的方式实现深复制。
测试代码：

public class Client3 {
    public static void main(String[] args) throws CloneNotSupportedException, Exception {
        Date date = new Date(12312321331L);
        Sheep s1 = new Sheep("我是一只羊",date);
        System.out.println(s1);
        System.out.println(s1.getSname());
        System.out.println(s1.getBirthday());

//      使用序列化和反序列化实现深复制
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream    oos = new ObjectOutputStream(bos);
        oos.writeObject(s1);
        byte[] bytes = bos.toByteArray();

        ByteArrayInputStream  bis = new ByteArrayInputStream(bytes);
        ObjectInputStream     ois = new ObjectInputStream(bis);

        Sheep s2 = (Sheep) ois.readObject();   //克隆好的对象！

        System.out.println("修改原型对象的属性值");  
        date.setTime(23432432423L);

        System.out.println(s1.getBirthday());

        s2.setSname("我是另一只羊");
        System.out.println(s2);
        System.out.println(s2.getSname());
        System.out.println(s2.getBirthday());
    }
}

运行结果：
com.gujian.prototype.Sheep@19189e1
我是一只羊
Sat May 23 20:05:21 CST 1970
修改原型对象的属性值
Tue Sep 29 13:00:32 CST 1970
com.gujian.prototype.Sheep@f73c1
我是另一只羊
Sat May 23 20:05:21 CST 1970
同样s1对象的修改并没有影响到s2。

原型模式的使用场景：
先比较普通new方式创建对象和clone方式创建对象的效率差异。
测试代码：

public class Client4 {

    public static void testNew(int size){
        long start = System.currentTimeMillis();
        for(int i=0;i<size;i++){
            Laptop t = new Laptop();
        }
        long end = System.currentTimeMillis();
        System.out.println("new的方式创建耗时："+(end-start));
    }

    public static void testClone(int size) throws CloneNotSupportedException{
        long start = System.currentTimeMillis();
        Laptop t = new Laptop();
        for(int i=0;i<size;i++){
            Laptop temp = (Laptop) t.clone();
        }
        long end = System.currentTimeMillis();
        System.out.println("clone的方式创建耗时："+(end-start));
    }


    public static void main(String[] args) throws Exception {   
        testNew(1000);
        testClone(1000);
    }
}


class Laptop implements Cloneable {  //笔记本电脑
    public Laptop() {
        try {
            Thread.sleep(10);  //模拟创建对象耗时的过程!
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj = super.clone();  //直接调用object对象的clone()方法！
        return obj;
    }

}

运行结果：
new的方式创建耗时：10328
clone的方式创建耗时：10
如果需要短时间创建大量对象，并且new的过程比较耗时。则可以考虑使用原型模式。

gujianoneyan
关注
专栏目录
原型模式Demo
11-28
http://blog.csdn.net/xingjiarong/article/details/50047443
23模式之: 原型模式demo
weixin_33860722的博客
07-05 89
浅克隆Demo: 羊: package prototype_mode; import java.util.Date; /** * 羊 * 对象要可以克隆, 需要实现空接口, 标记接口Cloneable, 这是规范 * clone是object方法, c实现, 效率极高 */ public class Sheep implements Cloneable { ...
原型模式
dengjuanshou7445的博客
09-05 93
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以...
设计模式系列之 原型模式
灯塔的CSDN博客
05-10 366
原型模式 原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据...
GOF之23种设计模式的C#实现：DesignPattern.zip
03-14
"GOF之23种设计模式"是由四名作者——Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides（通常称为Gang of Four，简称GOF）在他们的著作《设计模式：可复用面向对象软件的基础》中提出的。这些模式为创建可...
读书笔记：基于GoF《设计模式可复用面向对象软件的基础》的23种经典设计模式的javaDemo.zip
07-25
读书笔记：基于GoF《设计模式可复用面向对象软件的基础》的23种经典设计模式的javaDemo
Java23种设计模式可直接运行Demo.rar
10-07
在这个"Java23种设计模式可直接运行Demo.rar"压缩包中，包含了全部23种经典的GOF（GoF，Gamma, Helm, Johnson, Vlissides四位作者）设计模式的Java实现，这些模式包括创建型、结构型和行为型三大类。 1. **创建型...
设计模式demo
11-01
描述中的重复词汇“设计模式总结”暗示这是一个全面性的总结，可能涵盖了23种经典的GOF设计模式，包括创建型、结构型和行为型三大类。创建型模式如单例、工厂、抽象工厂、建造者和原型，它们关注对象的创建过程；...
设计模式demo示例.rar
04-06
设计模式的概念源自于《设计模式：可复用面向对象软件的基础》一书，由“Gang of Four”（GoF）提出，其中涵盖了23种经典的设计模式。这些模式分为创建型、结构型和行为型三大类，每一种都有其独特的应用场景和解决...
回顾设计模式之原型模式(Prototype Pattern),通过使用设计模式写Demo的方式记录一下,代码共享至码云
小怪爱鱼的博客
10-25 139
原型模式（Prototype Pattern）基本介绍 类型:属于创建模式 特点:用于创建重复的对象，同时又能保证性能,实现一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。 目的:摆脱构造方法,用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。对于复杂类的创建来说提高了效率。可以在运行期建立和删除原型 应用实例: 1、细胞分裂。 2、JAV...
GOF 23 设计模式之 原型模式(prototype) 深复制与浅复制举例
张博的Blog
09-22 546
原型模式初探 通过new产生一个对象需要复杂的数据准备或访问权限，可以使用原型模式。 就是Java的克隆技术，以某个对象为原型，复制出新的对象。显然，新的对象具备原型对象的特点 优势有：效率高（直接克隆，避免了重新执行构造函数的过程） 克隆类似于new，但是不同于new。new创建新的对象属性采用的是默认值。克隆出来的对象属性完全与原型对象相同。而且克隆出来的对象的属性值的修改不会影响到原型对象 原
GOF23 之 原型模式详解
weixin_45003863的博客
06-27 210
介绍 原型模式是指用原型实例指定创建对象的种类，通过拷贝这些原型创建新的对象。原型模式是一种创建型设计模式，允许一个对象在创建一个可定制对象，无需知道如何创建的细节。 工作原理 通过将一个原型对象传给一个要发动的对象，这个要发动创建的对象通过请求原型对象拷贝他们自己来实施创建，即对象.clone()。 简单理解：影分身之术。 原理结构 说明： Prototype:原型类，声明一个克隆自己的接口 ConcretePrototype:具体的原型类，实现了一个克隆自己的操作。 Client：让一个原型对象克隆自
Java设计模式——原型模式
weixin_30566111的博客
03-03 249
概述 原型模式是为了解决一些不必要的对象创建过程。当Java JDK中提供了Cloneable接口之后，原型模式就变得异常的简单了。虽然由于Cloneable的引入使用程序变得更简单了，不过还是有一些需要说明和注意的东西在里面的。文本就详细讲解一下这些注意事项吧。版权说明著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。本文作者：Coding-Naga发表日期： 2016年...
设计模式-原型模式
ZSS1753936255的博客
10-02 446
设计模式
滑动窗口-＞dd爱框框
robin_suli的博客
09-30 518
所以：当找到大于等于x的值时，right可以不用返回。1.进窗口：sum += array[right];3.出窗口：sum -= array[left];因此可以使用滑动窗口优化暴力解法。2.判断：sum >= x 时出窗口。灵活更新结果（满足结果后）因为元素都是大于0的。
JS进阶 3——深入面向对象、原型
最新发布
weixin_72043867的博客
10-03 1193
编程思想、JS面向对象使用构造函数进行封装、使用原型解决构造函数方法浪费内存的问题、什么是原型链、模态框封装案例
深入探索GoF23种设计模式的精髓
C++ 设计模式 GoF23 在软件开发中，设计模式是非常重要的一部分，它能够帮助开发者编写高质量、可维护、可扩展的代码。GoF（Gang of Four）提出了 23 种设计模式，这些模式已经被广泛应用于软件开发中。本文将对 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值