概念：

原型模式：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象。这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。

实现方式：

抽象原型类：规定了具体原型对象必须实现的clone()方法
具体原型类：实现抽象原型类的clone()方法，它是可被复制的对象
访问类：使用具体原型类的clone()方法来复制新的对象

原型模式分为浅克隆、深克隆

实现1：（浅克隆）

java中object类中提供了clone()方法来实现浅克隆， Cloneable接口就是抽象原型类，实现了Cloneable接口的子类就是具体的原型类。如下：

public class Phone implements Cloneable {
    private String name;
    public Phone() {
        System.out.println("调用构造方法创建对象");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    protected Phone clone() throws CloneNotSupportedException {
        System.out.println("调用克隆方法创建对象");
        return (Phone) super.clone();
    }
}

public class Test {
    public static void main(String[] args) {
        try {
            Phone phone1 = new Phone();
            phone1.setName("小米手机");
            Phone phone2 = phone1.clone();
            System.out.println("phone1: "+phone1.getName()+"\nphone2: "+phone2.getName());
            phone2.setName("华为手机");
            System.out.println("phone1: "+phone1.getName()+"\nphone2: "+phone2.getName());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

输出结果：

image.png

从输入结果可以看出，当调用原型类clone方法时，并没有再次调用构造方法。对象的属性也会一同被复制。

实现2：（深克隆）

还是以生产手机为例，这次我们在手机里添加一个CPU类引用。

public class Phone implements Cloneable, Serializable {
    private String name;
    private Cpu cpu;

    public String getName() {
        return name;
    }

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

    public Cpu getCpu() {
        return cpu;
    }

    public void setCpu(Cpu cpu) {
        this.cpu = cpu;
    }

    @Override
    protected Phone clone() throws CloneNotSupportedException {
        return (Phone) super.clone();
    }

    @Override
    public String toString() {
        return name + " : cpu name:" + cpu.getName() + " version:" + cpu.getVersion();
    }
}

public class Cpu implements Serializable {
    private String name;
    private String version;

    public String getName() {
        return name;
    }

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

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version;
    }
}

public class Test {
    public static void main(String[] args) {
        //一 浅克隆 引用对象指向原来的地址,修改属性值,都会一起修改
        try {
            Phone phone = new Phone();
            phone.setName("小米手机");
            Cpu cpu = new Cpu();
            cpu.setName("骁龙");
            cpu.setVersion("850");
            phone.setCpu(cpu);
            Phone phone2 = phone.clone();
            phone2.getCpu().setVersion("888");
            System.out.println(phone.toString());
            System.out.println(phone2.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("===============");
        //二 深克隆 通过序列化对象方式
        try {
            Phone phone = new Phone();
            phone.setName("华为手机");
            Cpu cpu = new Cpu();
            cpu.setName("麒麟");
            cpu.setVersion("900");
            phone.setCpu(cpu);

            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("***/b.txt"));
            oos.writeObject(phone);
            oos.close();

            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("***/b.txt"));
            Phone phone2 = (Phone) ois.readObject();
            ois.close();

            phone2.getCpu().setVersion("990");
            System.out.println(phone.toString());
            System.out.println(phone2.toString());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出结果：

image.png