Prototype模式简介

简介

用于创建重复的对象,同时又能保证性能。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时,则采用这种模式。

什么情况下使用原型设计模式呢?

一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象,在下一个请求时返回它的克隆,在需要的时候更新数据库,以此来减少数据库调用。

实现方式

  • c++ c++中可以通过实现拷贝构造函数的方法实现,要注意深拷贝和浅拷贝的问题。
  • java
    • 实现Cloneable接口,并覆写clone方法;
    • 使用对象流。使用对象流,所有的自定义类型需要实现Serializable接口。

prototype.png

抽象原型

class Prototype {
public:
    virtual Prototype * clone() = 0;
};

具体原型

class ContretePrototype :public Prototype {
private:
    char *name;
    int id;
public:
    ContretePrototype(const char *name, int id) {
        this->name = NULL;
        if (name != NULL) {
            //this->name = (char *)malloc(sizeof(char)*(strlen(name) + 1));
            this->name = new char[sizeof(char)*(strlen(name) + 1)];
            strcpy(this->name, name);
        }
        this->id = id;
    }
    ContretePrototype(const ContretePrototype& prototype) {
        this->name = NULL;
        if (prototype.getName() != NULL) {
            this->name = (char *)malloc(sizeof(char)*(strlen(prototype.getName()) + 1));
            strcpy(this->name, prototype.getName());
        }
        this->id = prototype.getId();
    }

    Prototype * clone() {
        ContretePrototype *prototype = new ContretePrototype(*this);
        return prototype;
    }
    ~ContretePrototype() {
        if (this->name != NULL) {
            //free (this->name);
            delete[]this->name;
        }
    }

    int getId()const {
        return this->id;
    }

    char * getName()const {
        return this->name;
    }
};

测试

int main()
{
    ContretePrototype p("abc", 1);
    cout << p.getName() << "  " << p.getId() << endl;
    ContretePrototype *p1 =dynamic_cast<ContretePrototype *>( p.clone());
    cout << p1->getName() << "  " << p1->getId() << endl;
    delete p1;
    return 0;
}

prototype_res.png

Java版

public class A  implements Cloneable,Serializable {
    private int x;
    private int y;

    public A(int x, int y) {
        this.x = x;
        this.y = y;
    }

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

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    @Override
    public String toString() {
        return "A{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
}
public class Prototype implements Cloneable, Serializable {
    private List<A> list;
    private A a;
    private int id;
    private String name;

    @Override
    protected Object clone() {
        Prototype o = null;
        try {
            o = (Prototype) super.clone();
            o.setA((A) o.getA().clone());
            List<A> temp = new ArrayList<A>(o.getList().size());
            for (A a : o.getList()) {
                temp.add((A) a.clone());
            }
            o.setList(temp);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }

    public Object deepClone() throws IOException, ClassNotFoundException {
        //将对象写到流里
        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        ObjectOutputStream oo = new ObjectOutputStream(bo);
        oo.writeObject(this);
        //从流里读出来
        ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
        ObjectInputStream oi = new ObjectInputStream(bi);
        return (oi.readObject());
    }

    public List<A> getList() {
        return list;
    }

    public void setList(List<A> list) {
        this.list = list;
    }

    public A getA() {
        return a;
    }

    public void setA(A a) {
        this.a = a;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Prototype{" +
                "list=" + list +
                ", a=" + a +
                ", id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}
public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //构造对象
        Prototype prototype = new Prototype();
        List<A> list = new ArrayList<A>();
        A a1 = new A(1, 2);
        A a2 = new A(10, 20);
        list.add(a1);
        list.add(a2);
        prototype.setList(list);
        A a3 = new A(100, 200);
        prototype.setA(a3);
        prototype.setId(1000);
        prototype.setName("prototype name");
        //打印对象内容
        log(prototype.toString());
        //使用clone克隆
        Prototype p1 = (Prototype) prototype.clone();
        //查看克隆后的结果
        log(p1.toString());
        //使用对象流序列化
        Prototype p2 = (Prototype) p1.deepClone();
        p1.getA().setX(300);
        p1.getList().get(0).setX(3000);
        log(prototype.toString());
        log(p2.toString());
    }


    public static void log(String content) {
        System.out.println(content);
    }
}

结果

Prototype{list=[A{x=1, y=2}, A{x=10, y=20}], a=A{x=100, y=200}, id=1000, name='prototype name'}
Prototype{list=[A{x=1, y=2}, A{x=10, y=20}], a=A{x=100, y=200}, id=1000, name='prototype name'}
Prototype{list=[A{x=1, y=2}, A{x=10, y=20}], a=A{x=100, y=200}, id=1000, name='prototype name'}
Prototype{list=[A{x=1, y=2}, A{x=10, y=20}], a=A{x=100, y=200}, id=1000, name='prototype name'}

Process finished with exit code 0

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏乐享123

Python编程实战 - 笔记1

1959
来自专栏LinkedBear的个人空间

设计模式笔记(五)——代理模式 原

通过实现一个与被代理对象的类相同的接口,完成被代理对象的实际方法调用。(接口性多态)

753
来自专栏Java爬坑系列

【Java入门提高篇】Day32 Java容器类详解(十四)ArrayDeque详解

  今天来介绍一个不太常见也不太常用的类——ArrayDeque,这是一个很不错的容器类,如果对它还不了解的话,那么就好好看看这篇文章吧。

942
来自专栏你不就像风一样

Java多线程核心技术(五)单例模式与多线程

什么是立即加载?立即加载就是使用类的时候已经将对象创建完毕,常见的实现办法就是直接 new 实例化。

693
来自专栏猿人谷

出栈顺序

之前参加过华北计算机研究所和优酷土豆的笔试,都考到出栈顺序,之前数据结构学的不到位,遇到这类题时,还着实把我愣了一会,现在总结下,省得以后再遇到这类问题,也希...

3376
来自专栏非著名程序员

解决TextView排版混乱或者自动换行的问题

其实在TextView中遇到排版自动换行而导致混乱不堪的情况是非常常见的,而且导致这种问题产生的原因就是英文和中文混合输入,半角字符和全角字符混合在一起了。一般...

5596
来自专栏我是攻城师

理解BitMap算法的原理

位图:一种常用的数据结构,代表了有限域中的稠集(dense set),每一个元素至少出现一次,没有其他的数据和元素相关联。在索引,数据压缩,海量数据处理等方面有...

1283
来自专栏函数式编程语言及工具

泛函编程(25)-泛函数据类型-Monad-Applicative

    上两期我们讨论了Monad。我们说Monad是个最有概括性(抽象性)的泛函数据类型,它可以覆盖绝大多数数据类型。任何数据类型只要能实现flatMap+u...

2519
来自专栏鸿的学习笔记

python的装饰器和闭包

因为在编译时,python会认为b是局部变量,这是python的一个设计选择,为了避免变量的污染,想一想。如果某人在函数内部改动了变量,你没有办法看到这个函数,

951
来自专栏CSDN技术头条

Java中的十个“单行代码编程”(One Liner)

本文列举了十个使用一行代码即可独立完成(不依赖其他代码)的业务逻辑,主要依赖的是 Java8 中的 Lambda 和 Stream 等新特性以及 try-wit...

1433

扫码关注云+社区

领取腾讯云代金券