Java设计模式（四）——————【创建型模式】设计模式之原型模式

最新推荐文章于 2024-09-01 16:58:50 发布
最新推荐文章于 2024-09-01 16:58:50 发布
阅读量218 收藏
点赞数
分类专栏： Java设计模式 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wmy1230/article/details/105258242
版权

源码地址：https://github.com/877148107/java-design-pattern 

目录

基本介绍

Spring中的原型模式

浅拷贝

1、案例说明

深拷贝

1、案例说明

总结

  • 基本介绍

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

2) 原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节

3) 工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即 对象.clone()

  • Spring中的原型模式

Spring使用的原型模式主要在bean配置上面@Scope("prototype")也就是多实例的，当IOC容器创建的时候并不会去将这个实例初始化到容器，而是每次获取的时候才会调用初始化创建方法。因此每使用一次就会创建一次每次创建的实例对象是一样的，但是每次创建的实例是不相等的也就是实例对应的内存地址不一样，这就是我对原型模式的理解。

  • 浅拷贝

1) 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。

2) 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值

3) 浅拷贝是使用默认的 clone()方法来实现

1、案例说明

一般情况我们使用的拷贝方法都是浅拷贝。浅拷贝的类图如下，Employee拷贝一个Employee2出来，他们本身引用的Department的指向实际是同一个内存地址的对象，后面对其中一个对象的修改都会影响到另一个成员变量。

public class CloneTest {

    public static void main(String[] args) throws CloneNotSupportedException {
        Department department = new Department("采购部");
        Employee employee = new Employee("张三",25,department);
        System.out.println("拷贝前employee："+employee+",HashCode:"+employee.getDepartment().hashCode());
        Employee employee2 = (Employee) employee.clone();
        System.out.println("拷贝后employee2："+employee2+",HashCode:"+employee2.getDepartment().hashCode());
        employee.getDepartment().setName("财务部");
        System.out.println("拷贝赋值后employee："+employee+",HashCode:"+employee.getDepartment().hashCode());
        System.out.println("拷贝赋值后employee2："+employee2+",HashCode:"+employee2.getDepartment().hashCode());
    }
}
public class Employee implements Cloneable {

    private String name;

    private int age;

    private Department department;

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

    public Employee(String name, int age, Department department) {
        this.name = name;
        this.age = age;
        this.department = department;
    }

    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 Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", department=" + department +
                '}';
    }
}

 

public class Department {

    private String name;

    public Department(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Department{" +
                "name='" + name + '\'' +
                '}';
    }
}

 测试结果：

拷贝前employee：Employee{name='张三', age=25, department=Department{name='采购部'}},HashCode:1163157884
拷贝后employee2：Employee{name='张三', age=25, department=Department{name='采购部'}},HashCode:1163157884
拷贝赋值后employee：Employee{name='张三', age=25, department=Department{name='财务部'}},HashCode:1163157884
拷贝赋值后employee2：Employee{name='张三', age=25, department=Department{name='财务部'}},HashCode:1163157884

  • 深拷贝

1) 复制对象的所有基本数据类型的成员变量值

2) 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝

3) 深拷贝实现方式1：重写clone方法来实现深拷贝

4) 深拷贝实现方式2：通过对象序列化实现深拷贝(推荐)

1、案例说明

深拷贝类图如下，也就是Employee拷贝得到Employee2，那么Employee的成员变量Department对象也会拷贝一份，两个Employee都指向不同的Department对象内存地址，拷贝前后修改属性值都不会影响到另一个对象。

 深拷贝方法一：使用clone方法进行深拷贝

public class CloneTest {

    public static void main(String[] args) throws CloneNotSupportedException {
        Department department = new Department("采购部");
        Employee employee = new Employee("张三",25,department);
        System.out.println("拷贝前employee："+employee+",HashCode:"+employee.getDepartment().hashCode());
        Employee employee2 = (Employee) employee.clone();
        System.out.println("拷贝后employee2："+employee2+",HashCode:"+employee2.getDepartment().hashCode());
        employee.getDepartment().setName("财务部");
        System.out.println("拷贝赋值后employee："+employee+",HashCode:"+employee.getDepartment().hashCode());
        System.out.println("拷贝赋值后employee2："+employee2+",HashCode:"+employee2.getDepartment().hashCode());
    }
}
public class Employee implements Cloneable {

    private String name;

    private int age;

    private Department department;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //这里只完成对基本数据的克隆
        Employee employee = (Employee) super.clone();
        //引用的数据类型单独进行克隆
        employee.department = (Department) department.clone();
        return employee;
    }

    public Employee(String name, int age, Department department) {
        this.name = name;
        this.age = age;
        this.department = department;
    }

    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 Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", department=" + department +
                '}';
    }
}
public class Department implements Cloneable{

    private String name;

    public Department(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

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

    @Override
    public String toString() {
        return "Department{" +
                "name='" + name + '\'' +
                '}';
    }
}

测试结果：

拷贝前employee：Employee{name='张三', age=25, department=Department{name='采购部'}},HashCode:1163157884
拷贝后employee2：Employee{name='张三', age=25, department=Department{name='采购部'}},HashCode:1956725890
拷贝赋值后employee：Employee{name='张三', age=25, department=Department{name='财务部'}},HashCode:1163157884
拷贝赋值后employee2：Employee{name='张三', age=25, department=Department{name='采购部'}},HashCode:1956725890

深拷贝方法二：

public class CloneTest {

    public static void main(String[] args) throws CloneNotSupportedException {
        Department department = new Department("采购部");
        Employee employee = new Employee("张三",25,department);
        System.out.println("拷贝前employee："+employee+",HashCode:"+employee.getDepartment().hashCode());
        Employee employee2 = (Employee) employee.deepClone();
        System.out.println("拷贝后employee2："+employee2+",HashCode:"+employee2.getDepartment().hashCode());
        employee.getDepartment().setName("财务部");
        System.out.println("拷贝赋值后employee："+employee+",HashCode:"+employee.getDepartment().hashCode());
        System.out.println("拷贝赋值后employee2："+employee2+",HashCode:"+employee2.getDepartment().hashCode());
    }
}
public class Employee implements Cloneable, Serializable {

    private String name;

    private int age;

    private Department department;

    /**
     * 深拷贝方式一
     * @return
     * @throws CloneNotSupportedException
     */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        //这里只完成对基本数据的克隆
        Employee employee = (Employee) super.clone();
        //引用的数据类型单独进行克隆
        employee.department = (Department) department.clone();
        return employee;
    }

    /**
     * 深拷贝方式二,通过对象序列化
     * @return
     */
    protected Object deepClone(){
        //创建流对象
        //字节输出流
        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);
            Employee employee = (Employee) ois.readObject();
            return employee;
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }finally {
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }


        //序列化

    }

    public Employee(String name, int age, Department department) {
        this.name = name;
        this.age = age;
        this.department = department;
    }

    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 Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", department=" + department +
                '}';
    }
}

 

public class Department implements Cloneable, Serializable {

    private String name;

    public Department(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

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

    @Override
    public String toString() {
        return "Department{" +
                "name='" + name + '\'' +
                '}';
    }
}

测试结果：

拷贝前employee：Employee{name='张三', age=25, department=Department{name='采购部'}},HashCode:1163157884
拷贝后employee2：Employee{name='张三', age=25, department=Department{name='采购部'}},HashCode:2065951873
拷贝赋值后employee：Employee{name='张三', age=25, department=Department{name='财务部'}},HashCode:1163157884
拷贝赋值后employee2：Employee{name='张三', age=25, department=Department{name='采购部'}},HashCode:2065951873

  • 总结

1) 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率

2) 不用重新初始化对象，而是动态地获得对象运行时的状态

3) 如果原始对象发生变化(增加或者减少属性)，其它克隆对象的也会发生相应的变化，无需修改代码

4) 在实现深克隆的时候可能需要比较复杂的代码

5) 缺点：需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了ocp原则

William.Wangmy
关注
专栏目录
Java设计模式——原型模式
01-20
Java设计模式——原型模式 原型模式Java设计模式——原型模式概念使用场景Java里的克隆代码理解prototype(原型)问题总结优缺点模型优点模型缺点 概念 ​ 原型模式是创建型模式的最后一种，讲到原型模式就不得不提到...
《java设计模式》课后习题模拟试题解答——刘伟.zip
12-26
本资料“《java设计模式》课后习题模拟试题解答——刘伟.zip”主要涵盖了Java设计模式的学习与应用，特别是针对刘伟教授的相关课程的课后习题及模拟试题的解答。 设计模式分为三大类：创建型、结构型和行为型模式。...
漫谈Java（2-3） - 创建对象
gogy的专栏
04-19 227
​2.3.1虚位以待——声明对象 让我们设想这样一种场景，咖啡馆需要招聘一名新员工。在经过了一系列的财务预算、确定新员工的职责等流程之后，我们发布虚位以待的信息——诚聘一名新员工。这样，其他人就知道咖啡店需要一名员工。在Java中，当我们需要由建好的类产生一个对象，就需要向系统声明一个对象，告知系统我们现在需要一个对象。声明对象的语法如下： Employee employee; 声明一个...
Employee employee = new Employee()，此时employee对象不等于空；若Employee employee = null，则employee对象为空。
努力努力，努力努力的博客
09-14 392
Employee employee = new Employee()，此时employee对象不等于空；若Employee employee = null，则employee对象为空。
java employee_java之Employee
weixin_33512578的博客
02-21 930
package learning;import java.util.*;import java.io.*;public class Employee{String name;int age;String designation;double salary;public Employee(String name) {this.name = name;}public void empAge(int e...
Employee emp = new Employee()和emp = new Employee()
weixin_30325793的博客
12-20 1405
List<Employee> employees = new List<Employee>(); Employee emp = new Employee(); emp.FirstName = "Jack"; emp.LastName = "Ma"; emp.Salary = 20000; employees.Add(emp); emp.FirstName...
Java设计模式（四）—— 原型模式
weixin_49561506的博客
03-25 1333
设计模式的原型模式，介绍了三种原型模式实现方式的浅复制和深复制
Java 设计模式——原型模式
代码星辰的博客
07-22 1350
本文介绍了原型模式的相关知识。
java设计模式（一）——五种创建型设计模式
qq_36967200的博客
11-09 2067
一、什么是设计模式？ 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，
JAVA设计模式——【原型模式】
最新发布
2401_86352702的博客
09-01 1209
Java架构进阶面试及知识点文档笔记这份文档共498页，其中包括Java集合，并发编程，JVM，Dubbo,Redis，Spring全家桶，MySQL，Kafka等面试解析及知识点整理Java分布式高级面试问题解析文档其中都是包括分布式的面试问题解析，内容有分布式消息队列，Redis缓存，分库分表，微服务架构，分布式高可用，读写分离等等！互联网Java程序员面试必备问题解析及文档学习笔记Java架构进阶视频解析合集来实现深拷贝④深拷贝实现方式2:通过对象序列化实现深拷贝(推荐)深拷贝应用案例;
创建型设计模式——原型模式
★★光亭★★
02-11 5736
创建型设计模式——原型模式
设计模式——JAVA.docx
04-03
### JAVA设计模式总结之23种设计模式及六大原则 #### 一、设计模式之六大原则 ##### 总原则：开闭原则（Open Close Principle） 开闭原则是设计模式中最核心的原则之一，它强调的是软件实体（类、模块、函数等）...
Java设计模式（一）——————设计模式介绍，设计模式七大原则
不积跬步无以至千里
03-23 1213
什么是设计模式 软件设计模式（Design pattern），又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。 设计模式的目的​​​​​​​ 1）、代码重用性（相同功能的代码，不用多次编写） 2）、可读性（编程规范性，便于其他人的阅读和理解） 3）、可扩展性（...
Java设计模式（十六）——————【行为型模式】设计模式之迭代器模式
不积跬步无以至千里
06-27 443
源码地址：【行为型模式】设计模式之迭代器模式 目录基本介绍基本原理应用案例1、需求2、UML类图3、代码实现源码分析总结 基本介绍 迭代器模式（Iterator Pattern）是常用的设计模式，属于行为型模式 如果我们的集合元素是用不同的方式实现的，有数组，还有java的集合类，或者还有其他方式，当客户端要遍历这些集合元素的时候就要使用多种遍历方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决。 迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道
Java设计模式（十五）——————【行为型模式】设计模式之访问者模式
不积跬步无以至千里
06-27 435
源码地址：【行为型模式】设计模式之访问者模式 目录基本介绍基本原理应用案例1、需求2、UML类图3、代码实现总结 基本介绍 访问者模式（Visitor Pattern），封装一些作用于某种数据结构的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。 主要将数据结构与数据操作分离，解决 数据结构和操作耦合性问题 访问者模式的基本工作原理是：在被访问的类里面加一个对外提供接待访问者的接口 访问者模式主要应用场景是：需要对一个对象结构中的对象进行很多不同操作(这些操
Java设计模式（三）——————【创建型模式】设计模式之简单工厂模式、工厂方法模式、抽象工厂模式
不积跬步无以至千里
03-30 383
源码地址：https://github.com/877148107/java-design-pattern 目录 工厂模式说明 传统方式实现 1、UML类图 2、代码实现 3、总结 简单工厂（静态工厂）模式 1、UML类图 2、代码实现 工厂方法模式 1、UML类图 2、代码实现 抽象工厂模式 1、UML类图 2、代码实现 工厂模式说明 我们利用一个需...
Java设计模式（九）——————【结构型模式】设计模式之组合模式
不积跬步无以至千里
04-14 350
源码地址：https://github.com/877148107/java-design-pattern 目录基本介绍基本原理案例说明1、需求2、UML类图3、代码实现JDK源码分析总结 基本介绍 1）组合模式（Composite Pattern），又叫部分整体模式，它创建了对象组的树形结构，将对象组合成树状结构以表示“整体-部分”的层次关系。 2）组合模式依据树形结构来组合对象，用来...
Java设计模式（十七）——————【行为型模式】设计模式之观察者模式
不积跬步无以至千里
06-27 302
源码地址：【行为型模式】设计模式之观察者模式 目录基本介绍基本原理应用案例1、需求2、类图3、代码实现源码分析总结 基本介绍 观察者模式（有时又被称为模型（Model）-视图（View）模式、源-收听者(Listener)模式或从属者模式）是软件设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统。 观察者模式（Observer），又叫发布-订阅模式（Publish/Su
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值