原型模式

原型模式(Prototype)：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

原型模式结构图

通俗来说：原型模式就是深拷贝和浅拷贝的实现。

浅拷贝

只实现了值拷贝，对于引用对象还是指向原来的对象。

• 父类实现clone方法，子类没有实现clone方法，其效果是浅拷贝。
• 父类实现clone方法，子类也实现clone方法，本来我想应该是深拷贝了，没想到也是浅拷贝。

package com.prototype;
import java.io.Serializable;

public class Work implements Serializable,Cloneable{
    private static final long serialVersionUID = 207835812839542204L;
    private String job;
    private double salary;
    public Work(String job,double salary) {
        this.job = job;
        this.salary = salary;
    }
    @Override
    public String toString() {
        return "Work [job=" + job + ", salary=" + salary + "]";
    }
    public String getJob() {
        return job;
    }
    public void setJob(String job) {
        this.job = job;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
}

package com.prototype;

import java.io.Serializable;

public class User implements Serializable,Cloneable{
    private static final long serialVersionUID = -2260332138558500447L;
    
    private String name = "";
    private Work work = null;
    
    public User(String name,String job,double salary) {
        this.name=name;
        work = new Work(job, salary);
    }
    
    public void changeJob(String job){
        this.work.setJob(job);
    }
    /*只需要实现Cloneable接口，覆写clone方法，此处clone方法可以改成任意的名称，
    因为Cloneable接口是个空接口，你可以任意定义实现类的方法名，如cloneA或者cloneB。
    重点是super.clone()这句话，super.clone()调用的是Object的clone()方法，而在Object类中，clone()是native的。
    */
    //浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "User [name=" + name + ", work=" + work + "]";
    }

}

package com.prototype;

public class Main {

    public static void main(String[] args) {
        try {
            User user1 = new User("zhangsan","ceo",100000);
            User user2 = (User) user1.clone();
            System.out.println(user1);
            System.out.println(user2);
            System.out.println("修改job");
            user2.changeJob("cfo");
            System.out.println(user1);
            System.out.println(user2);
            
            
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

//结果
User [name=zhangsan, work=Work [job=ceo, salary=100000.0]]
User [name=zhangsan, work=Work [job=ceo, salary=100000.0]]
修改job
User [name=zhangsan, work=Work [job=cfo, salary=100000.0]]
User [name=zhangsan, work=Work [job=cfo, salary=100000.0]]

深拷贝

即实现了值拷贝，也实现了对引用对象的拷贝。

• 法一

    //深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。
    //实现深复制，需要采用流的形式读入当前对象的二进制输入，再写出二进制数据对应的对象。
    public Object deepClone() throws IOException, ClassNotFoundException{
        //写入当前对象的二进制流
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        
        //读入二进制流产生的新对象
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }

• 法二

    //将User的拷贝方法修改为下面的方法。
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Work w = (Work) work.clone();//对其引用变量进行拷贝
        User u = (User)super.clone();//自身拷贝
        u.work = w;//引用变量重新赋值。
        return u;
    }