乐趣区

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

写在后面

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

学习地址

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 原型模式的注意事项和细节

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

写在最初

  • 如果我的文章对你有用,请给我点个👍,感激你😊!
  • 有问题,欢送在评论区指出!💪
退出移动版