写在后面

记录学习设计模式的笔记
进步对设计模式的灵活运用

学习地址

https://www.bilibili.com/vide...

参考文章

http://c.biancheng.net/view/1...

我的项目源码
https://gitee.com/zhuang-kang/DesignPattern

6，原型模式

6.1原形模式的定义和特点

原型（Prototype）模式的定义如下：用一个曾经创立的实例作为原型，通过复制该原型对象来创立一个和原型雷同或类似的新对象。在这里，原型实例指定了要创立的对象的品种。用这种形式创建对象十分高效，基本毋庸晓得对象创立的细节。例如，Windows 操作系统的装置通常较耗时，如果复制就快了很多。

原型模式的长处：

Java自带的原型模式基于内存二进制流的复制，在性能上比间接 new 一个对象更加低劣。
能够应用深克隆形式保留对象的状态，应用原型模式将对象复制一份，并将其状态保存起来，简化了创建对象的过程，以便在须要的时候应用（例如复原到历史某一状态），可辅助实现撤销操作。

原型模式的毛病：

须要为每一个类都配置一个 clone 办法
clone 办法位于类的外部，当对已有类进行革新的时候，须要批改代码，违反了开闭准则。
当实现深克隆时，须要编写较为简单的代码，而且当对象之间存在多重嵌套援用时，为了实现深克隆，每一层对象对应的类都必须反对深克隆，实现起来会比拟麻烦。因而，深克隆、浅克隆须要使用切当。

6.2 原型模式的构造与实现

6.2.1 原形模式的构造

原型模式蕴含以下次要角色。

形象原型类：规定了具体原型对象必须实现的接口。
具体原型类：实现形象原型类的 clone() 办法，它是可被复制的对象。
拜访类：应用具体原型类中的 clone() 办法来复制新的对象。

6.2.2 代码实现

浅克隆：创立一个新对象，新对象的属性和原来对象完全相同，对于非根本类型属性，仍指向原有属性所指向的对象的内存地址。
深克隆：创立一个新对象，属性中援用的其余对象也会被克隆，不再指向原有对象地址。

6.2.2.1 浅拷贝

IdCard

package com.zhuang.prototype.shallowclone;/** * @Classname IdCard * @Description 浅拷贝的示例 * @Date 2021/3/19 12:16 * @Created by dell */public class IdCard {    private String id;    public IdCard(String id) {        this.id = id;    }    @Override    public String toString() {        return "IdCard{" +                "id=" + id +                '}';    }}

Person

package com.zhuang.prototype.shallowclone;/** * @Classname Person * @Description 浅拷贝的示例 * @Date 2021/3/19 12:17 * @Created by dell */public class Person implements Cloneable {    private String name;    private int age;    private IdCard idCard;    public Person() {    }    public Person(String name, int age, IdCard idCard) {        this.name = name;        this.age = age;        this.idCard = idCard;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    public IdCard getIdCard() {        return idCard;    }    public void setIdCard(IdCard idCard) {        this.idCard = idCard;    }    @Override    public String toString() {        return "Person{" +                "name='" + name + '\'' +                ", age=" + age +                ", idCard=" + idCard + ", idCard.hashCode=" + idCard.hashCode() +                '}';    }    @Override    protected Object clone() throws CloneNotSupportedException {        return super.clone();    }}

PersonTest

package com.zhuang.prototype.shallowclone;/** * @Classname PersonTest * @Description 浅拷贝测试类 * @Date 2021/3/19 12:17 * @Created by dell */public class PersonTest {    public static void main(String[] args) throws Exception {        Person person = new Person("张三", 20, new IdCard("10086"));        Person person1 = (Person) person.clone();        Person person2 = (Person) person.clone();        System.out.println(person);        System.out.println(person1);        System.out.println(person2);    }}

咱们发现能够通过实现implements Cloneable来实现浅拷贝，根本变量是值传递克隆，而援用对象IdCard则是援用传递，这不合乎咱们面向对象思维，每一个Person应该都有一个独立的IdCard，而不是共用一个，而要解决这种问题，咱们须要应用深克隆

6.2.2.2 深拷贝(第一种)

IdCard

package com.zhuang.prototype.deepclone.one;/** * @Classname IdCard * @Description 深克隆的示例 * @Date 2021/3/19 12:33 * @Created by dell *///实现Cloneable接口public class IdCard implements Cloneable {    private String id;    public IdCard(String id) {        this.id = id;    }    public String getId() {        return id;    }    public void setId(String id) {        this.id = id;    }    @Override    public String toString() {        return "IdCard{" +                "id='" + id + '\'' +                '}';    }    @Override    protected Object clone() throws CloneNotSupportedException {        return super.clone();    }}

Person

package com.zhuang.prototype.deepclone.one;/** * @Classname Person * @Description 深克隆的示例 * @Date 2021/3/19 12:33 * @Created by dell */public class Person implements Cloneable {    private String name;    private int age;    private IdCard idCard;    public Person(String name, int age, IdCard idCard) {        this.name = name;        this.age = age;        this.idCard = idCard;    }    public IdCard getIdCard() {        return idCard;    }    public void setIdCard(IdCard idCard) {        this.idCard = idCard;    }    @Override    public String toString() {        return "Person{" +                "personHashCode=" + this.hashCode() +                ", name='" + name + '\'' +                ", age=" + age +                ", idCard=" + idCard +                ", idCardHashCode=" + idCard.hashCode() +                '}';    }    //深克隆须要本人手动实现，在对象援用中也要实现clone办法    @Override    protected Object clone() throws CloneNotSupportedException {        //实现根本数据类型的拷贝        //通过new关键字创立的对象是援用类型        Object person = super.clone();        //对援用类型独自解决        Person p = (Person) person;        IdCard idCard = (IdCard) p.getIdCard().clone(); //实现本人的克隆        p.setIdCard(idCard);        return p;    }}

PersonTest

package com.zhuang.prototype.deepclone.one;import java.io.Serializable;/** * @Classname PersonTest * @Description 深克隆测试类 * @Date 2021/3/19 12:33 * @Created by dell */public class PersonTest implements Serializable {    public static void main(String[] args) throws Exception {        Person person = new Person("张三", 20, new IdCard("10086"));        Person person1 = (Person) person.clone();        Person person2 = (Person) person.clone();        System.out.println(person);        System.out.println(person1);        System.out.println(person2);    }}

应用这种深克隆的形式，完满的解决了当数据类型为援用类型时，只是拷贝原援用对象地址而不是一个全新的援用对象的援用，然而这种实现有一个很大的弊病，须要在每一个对象中都实现clone办法，如果类全是你本人写的，那天然没问题，实现一下就行了，不过有点麻烦。然而，如果你援用的是第三方的一个类，无奈批改源代码，这种形式，显然就无奈实现深克隆了

6.2.2.2 深拷贝(第二种)

IdCard

package com.zhuang.prototype.deepclone.two;/** * @Classname IdCard * @Description 深克隆的示例2 * @Date 2021/3/19 12:33 * @Created by dell *///实现Serializable接口public class IdCard implements Serializable {    private String id;    public IdCard(String id) {        this.id = id;    }    public String getId() {        return id;    }    public void setId(String id) {        this.id = id;    }    @Override    public String toString() {        return "IdCard{" +                "id='" + id + '\'' +                '}';    }    @Override    protected Object clone() throws CloneNotSupportedException {        return super.clone();    }}

Person

package com.zhuang.prototype.deepclone.two;import java.io.*;/** * @Classname Person * @Description 深克隆的示例2 * @Date 2021/3/19 12:33 * @Created by dell */public class Person implements Serializable {    private String name;    private int age;    private IdCard idCard;    public Person(String name, int age, IdCard idCard) {        this.name = name;        this.age = age;        this.idCard = idCard;    }    public IdCard getIdCard() {        return idCard;    }    public void setIdCard(IdCard idCard) {        this.idCard = idCard;    }    @Override    public String toString() {        return "Person{" +                "personHashCode=" + this.hashCode() +                ", name='" + name + '\'' +                ", age=" + age +                ", idCard=" + idCard +                ", idCardHashCode=" + idCard.hashCode() +                '}';    }    //序列化的形式    public Person deelClone() {        //创立流对象        ByteArrayOutputStream bos = null;        ObjectOutputStream oos = null;        ByteArrayInputStream bis = null;        ObjectInputStream ois = null;        try {            //序列化            bos = new ByteArrayOutputStream();            oos = new ObjectOutputStream(bos);            oos.writeObject(this);            //反序列化            bis = new ByteArrayInputStream(bos.toByteArray());            ois = new ObjectInputStream(bis);            return (Person) ois.readObject();        } catch (Exception e) {            e.printStackTrace();            return null;        } finally {            try {                ois.close();                bis.close();                oos.close();                bos.close();            } catch (IOException e) {                e.printStackTrace();            }        }    }}

PersonTest

package com.zhuang.prototype.deepclone.two;/** * @Classname PersonTest * @Description 深克隆测试类 * @Date 2021/3/19 12:33 * @Created by dell */public class PersonTest {    public static void main(String[] args) throws Exception {        //创立一个对象        Person person = new Person("张三", 20, new IdCard("10086"));        //克隆两个对象        Person person1 = (Person) person.deelClone();        Person person2 = (Person) person.deelClone();        System.out.println("深拷贝(第二种 实现序列化接口)");        //打印三人信息        System.out.println(person);        System.out.println(person1);        System.out.println(person2);    }}

这种形式咱们须要手动编写deepClone办法，应用Java流中的序列化与反序列化来实现深克隆，然而这种实现，须要在每一个类中都继承序列化Serializable接口，这种形式，如果你调用的是第三方类，也有可能第三方类上没有实现Serializable序列化接口，然而一般来说，大多都会实现，总的来说，这种比拟举荐应用，而且效率也高

6.3 原型模式的利用场景

对象之间雷同或类似，即只是个别的几个属性不同的时候。
创建对象老本较大，例如初始化工夫长，占用CPU太多，或者占用网络资源太多等，须要优化资源。
创立一个对象须要繁琐的数据筹备或拜访权限等，须要进步性能或者进步安全性。
零碎中大量应用该类对象，且各个调用者都须要给它的属性从新赋值。
在 Spring中，原型模式利用的十分宽泛，例如 scope='prototype'、JSON.parseObject() 等都是原型模式的具体利用。

6.4 原型模式的注意事项和细节

创立新的对象比较复杂时，能够利用原型模式简化对象的创立过程，同时也能提高效率
不必从新初始化对象，动静地取得对象运行时的状态
如果原始对象发生变化(减少或缩小属性)，其余克隆对象也会产生相应的变动，无需批改代码

写在最初

如果我的文章对你有用，请给我点个，感激你！
有问题，欢送在评论区指出！