设计模式七之原型模式

  在一些系统中，存在大量相同或相似对象的创建问题，如果用传统的构造函数来创建对象，会比较复杂且耗时耗资源。所以用原型模式生成对象就比较方便和高效。

1. 模式的定义与特点

1.1 模式的定义

  原型模式（prototype）：用一个已经创建好的对象作为原型，通过复制该原型对象来创建一个和原型对象相同或相似的新对象。

1.2 模式的适用场景

  1. 类初始化消耗较多资源；
  2. new 产生的对象需要非常繁琐的过程（数据准备、访问权限等）；
  3. 构造函数比较复杂；
  4. 循环体中产生大量的对象时。

2. 模式的结构与实现

2.1 模式的实现

/**
 * 原型模式
 */
public class Mail implements Cloneable {

    private String to;
    private String from;
    private String title;
    private String content;
    private Date time;

    public Mail() {
        System.out.println("mail class Constructor ...");
    }

    public String getTo() {
        return to;
    }

    public void setTo(String to) {
        this.to = to;
    }

    public String getFrom() {
        return from;
    }

    public void setFrom(String from) {
        this.from = from;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Date getTime() {
        return time;
    }

    public void setTime(Date time) {
        this.time = time;
    }

    @Override
    public String toString() {
        return "Mail{" +
                "to='" + to + '\'' +
                ", from='" + from + '\'' +
                ", title='" + title + '\'' +
                ", content='" + content + '\'' +
                ", time=" + time +
                '}' + "\n" + super.toString() + "\n";
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {

        /**
         * 深拷贝
         */
        /*Mail mail = (Mail) super.clone();
        mail.time = (Date) mail.time.clone();
        return mail;*/

        /**
         * 前拷贝
         */
        System.out.println("clone mail object");
        return super.clone();
    }
}

客户端

public class Client {

    public static void main(String[] args) {
        Mail mail = new Mail();
        mail.setContent("初始化内容");
        mail.setTime(new Date(0L));
        System.out.println(mail);

        Stream.iterate(0, i -> i + 1).limit(5).forEach(i -> {
            try {
                Mail mailClone = (Mail) mail.clone();
                mailClone.setFrom("from_" + i);
                mailClone.setTo("to_" + i);
                mailClone.setContent("content_" + i);
                mailClone.setTitle("titile_" + i);
                mailClone.setTime(new Date());
                System.out.println(mailClone);
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
        });

        System.out.println(mail);
    }

}

# 运行结果如下：
mail class Constructor ...
Mail{to='null', from='null', title='null', content='初始化内容', time=Thu Jan 01 08:00:00 CST 1970}
com.baidu.test.disign.creational.prototype.Mail@4dc63996

clone mail object
Mail{to='to_0', from='from_0', title='titile_0', content='content_0', time=Thu Mar 05 17:44:27 CST 2020}
com.baidu.test.disign.creational.prototype.Mail@7cc355be

clone mail object
Mail{to='to_1', from='from_1', title='titile_1', content='content_1', time=Thu Mar 05 17:44:27 CST 2020}
com.baidu.test.disign.creational.prototype.Mail@6e8cf4c6

clone mail object
Mail{to='to_2', from='from_2', title='titile_2', content='content_2', time=Thu Mar 05 17:44:27 CST 2020}
com.baidu.test.disign.creational.prototype.Mail@12edcd21

clone mail object
Mail{to='to_3', from='from_3', title='titile_3', content='content_3', time=Thu Mar 05 17:44:27 CST 2020}
com.baidu.test.disign.creational.prototype.Mail@34c45dca

clone mail object
Mail{to='to_4', from='from_4', title='titile_4', content='content_4', time=Thu Mar 05 17:44:27 CST 2020}
com.baidu.test.disign.creational.prototype.Mail@52cc8049

Mail{to='null', from='null', title='null', content='初始化内容', time=Thu Jan 01 08:00:00 CST 1970}
com.baidu.test.disign.creational.prototype.Mail@4dc63996

浅拷贝与深拷贝：
  浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。即默认拷贝构造函数只是对对象进行浅拷贝复制(逐个成员依次拷贝)，即只复制对象空间而不复制资源。
  深拷贝，在拷贝引用类型成员变量时，为引用类型的数据成员另辟了一个独立的内存空间，实现真正内容上的拷贝。