乐趣区

关于java:设计模式学习05Java实现原型模式

作者：

jiezi

在

写在后面

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

学习地址

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

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 原形模式的构造

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

  1. 形象原型类：规定了具体原型对象必须实现的接口。
  2. 具体原型类：实现形象原型类的 clone() 办法，它是可被复制的对象。
  3. 拜访类：应用具体原型类中的 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 原型模式的注意事项和细节

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

写在最初

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

评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

这个站点使用 Akismet 来减少垃圾评论。了解你的评论数据如何被处理。

更多文章