初始设计模式---原型模式

原型模式

学习目标
是什么？
浅复制
深复制

原型模式其实就是从一个对象再创建另外一个可定制的对象，而且不需知道任何创建细节
在现实中有这样的场景。

public class Money {

      //面额
    private int num;
    //印刷时间
    private String time;
    
    public Money(){
        System.out.println("赚钱（创建）中。。。");
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
    public String getTime() {
        return time;
    }
    public void setTime(String time) {
        this.time = time;
    }
}

大家都知道赚钱是很辛苦的，当我们想赚很多钱的时候，通过都是这样

Money m1 = new Money();
m1.setNum(1);
m1.setTime("2014");
        
Money m2 = new Money();
m1.setNum(5);
m1.setTime("2014");
        
        
Money m2 = new Money();
m1.setNum(10);
m1.setTime("2014");

OMG!简直要疯。。。。

心疼.jpg

只是部分属性不同，却需要多次创建对象，这样代码看起来十分臃肿且没有效率
那么如何来避免多次实例化对象呢？

下面看看原型模式的简单实现
实现Cloneable接口

public class Money implements Cloneable {

    //面额
    private int num;
    //印刷时间
    private String time;
    
    public Money(){
        System.out.println("赚钱（创建）中。。。");
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
    public String getTime() {
        return time;
    }
    public void setTime(String time) {
        this.time = time;
    }

    @Override
    public String toString() {
        return "Money [num=" + num + ", time=" + time + "]";
    }
    @Override
    public Money clone(){
        try {
            return (Money) super.clone();
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }
}```

测试一下~
```java
Money m1 = new Money();
m1.setNum(1);
m1.setTime("2014");
        
Money m2 = m1.clone();
m2.setNum(10000);
        
System.out.println(m1);
System.out.println(m2);

运行结果~

赚钱（创建）中。。。
Money [num=1, time=2014]
Money [num=10000, time=2014]

哇哈哈哈哈哈，发现钱都不用赚了，可以复制了

值得注意的是，如果类中引用类型的对象，那么就只复制了引用但不复制引用的对象
，则只是复制了引用，但没有负责引用的对象，因此，复制的对象的原本的对象都是同一个引用

假设我们给Money添加一个生产money的工厂类

//生产Money的工厂
public class Factory {

    private String name;

    。。。省略

TEST

Money m1 = new Money();
m1.setNum(1);
m1.setTime("2014");
m1.setFactory(new Factory("龙岗印刷厂"));
        
Money m2 = m1.clone();
m2.setNum(10000);
m2.getFactory().setName("小梅沙印刷厂");
        
System.out.println(m1.getFactory().getName());
System.out.println(m2.getFactory().getName());

运行·结果·

赚钱（创建）中。。。
小梅沙印刷厂
小梅沙印刷厂

0.0发现工厂名称随着修改了，其实Factory都是指向同一个对象
没有复制引用类型，这个就叫做“浅复制“

浅复制:被复制的对象的所有变量都含有原来对象的值，而所有的对其他对象的引用都仍然指向原来的对象。

那么如何解决呢？
我们想把的引用对象的变量指向复制过来的对象，不是指向原来被引用的对象
有点绕口。。。这个就是”深复制"了
其实相当简单，看下代码就知道了

让Factory也实现Cloneable

@Override
    protected Factory clone()  {
        // TODO Auto-generated method stub
        try {
            return (Factory) super.clone();
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

在Money中，完成对Factory的copy

public Money(Factory factory) {
        this.factory = factory.clone();
}```
然后就是money的clone
```java
        @Override
    public Money clone() {
        Money money = null;
        money = new Money(this.factory);
        money.setNum(this.num);
        money.setTime(this.time);
        return money;
    }```

读《大话设计模式》笔记之~