设计模式篇(Java):原型模式

这篇具有很好参考价值的文章主要介绍了设计模式篇(Java):原型模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

上一篇:设计模式篇(Java):工厂模式

六、原型模式

需求示例—>克隆羊

现在有一只羊tom,姓名为: tom, 年龄为:1,颜色为:白色,请编写程序创建和tom 羊属性完全相同的10只羊。

不使用设计模式(传统方式)实现:

/**
 * @author cVzhanshi
 * @create 2023-04-18 16:12
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Sheep {
    String name;

    Integer age;

    String color;
}

// ======================================================

/**
 * @author cVzhanshi
 * @create 2023-04-18 16:14
 */
@Slf4j
public class Client {
    public static void main(String[] args) {
        Sheep sheep = new Sheep("tom", 1, "白色");

        Sheep sheep1 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());

        log.info(sheep.toString());
        log.info(sheep1.toString());
        log.info(sheep2.toString());
        log.info(sheep3.toString());
    }
}

分析:

  • 优点是比较好理解,简单易操作。
  • 在创建新的对象时,总是需要重新获取原始对象的属性,如果创建的对象比较复杂时,效率较低
  • 总是需要重新初始化对象,而不是动态地获得对象运行时的状态, 不够灵活。

优化思路:

Java中Object类是所有类的根类,Object类提供了一个clone()方法,该方法可以将一个Java对象复制一份,但是需要实现clone的Java类必须要实现一个接口Cloneable, 该接口表示该类能够复制且具有复制的能力 => 原型模式

6.1 原型模式基本介绍

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

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

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

代码演示:

/**
 * @author cVzhanshi
 * @create 2023-04-18 16:12
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Sheep implements Cloneable {
    String name;

    Integer age;

    String color;

    @Override
    public Sheep clone() {
        try {
            Sheep clone = (Sheep) super.clone();
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

/**
 * @author cVzhanshi
 * @create 2023-04-18 16:14
 */
@Slf4j
public class Client {
    public static void main(String[] args) {
        Sheep sheep = new Sheep("tom", 1, "白色");

        Sheep sheep1 = sheep.clone();
        Sheep sheep2 = sheep.clone();

        log.info(sheep.toString()); // tom
        log.info(sheep1.toString()); // tom
        log.info(sheep2.toString()); // tom

        log.info("{}", sheep);
        log.info("{}", sheep1);
        log.info("{}", sheep2);
        log.info("{}", sheep2 == sheep1);   // fasle
        log.info("{}", sheep1.equals(sheep));  // true  因为实体类用了@Data注解,其实是帮帮助我们重写了equals方法的

        sheep.setName("cvzhanshi");
        log.info(sheep.toString());  // cvzhanshi
        log.info(sheep1.toString()); // tom 
        log.info(sheep2.toString()); // tom
    }
}

6.2 jdk代码中的使用

其中spring源码创建bean的代码中就与使用

<bean id="id01" class="com.atguigu.spring.bean.Monster" scope="prototype"/>

其中的scope就可以选择prototype

获取bean的代码

ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
context.getBean("id");



==> getBean();
@Override
public Object getBean(String name) throws BeansException {
    assertBeanFactoryActive();
    return getBeanFactory().getBean(name);
}    

==>getBeanFactory().getBean(name);
protected <T> T doGetBean(
    String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    throws BeansException {
    //    ...
    if (mbd.isSingleton()) { // 单例
       
    }

    else if (mbd.isPrototype()) {  // 原型
        // It's a prototype -> create a new instance.  创建新的实例
        Object prototypeInstance = null;
        try {
            beforePrototypeCreation(beanName);
            prototypeInstance = createBean(beanName, mbd, args);
        }
        finally {
            afterPrototypeCreation(beanName);
        }
        beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
    }

    else { // 其他
        
    }
    //    ...
}

6.3 浅拷贝和深拷贝

浅拷贝

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

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

上述示例使用的就是浅拷贝,浅拷贝默认使用的是clone()方法来实现的

深拷贝

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

深拷贝实现方式1:重写clone方法来实现深拷贝

深拷贝实现方式2:通过对象序列化实现深拷贝

代码演示

  • 重写clone方法来实现深拷贝,把对象里面的引用对象也重写clone

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class DeepProtoType implements Serializable, Cloneable {
    
        public String name; //String 属性
        public DeepCloneableTarget deepCloneableTarget;  // 引用类型 也需要重写
    
    
        @Override
        public DeepProtoType clone() {
            try {
                DeepProtoType clone = (DeepProtoType) super.clone();
                // 把重写的值赋值给对象
                clone.deepCloneableTarget = deepCloneableTarget.clone();
                return clone;
            } catch (CloneNotSupportedException e) {
                throw new AssertionError();
            }
        }
    }
    
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class DeepCloneableTarget implements Serializable, Cloneable  {
    
        private String cloneName;
    
        private String cloneClass;
    
    
        @Override
        public DeepCloneableTarget clone() {
            try {
                return (DeepCloneableTarget) super.clone();
            } catch (CloneNotSupportedException e) {
                throw new AssertionError();
            }
        }
    }
    
  • 通过对象序列化实现深拷贝

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class DeepProtoType implements Serializable {
    
        public String name; //String 属性
        public DeepCloneableTarget deepCloneableTarget;  // 引用类型
    
        public DeepProtoType deepClone() {
            ObjectOutputStream oos = null;
            ByteArrayOutputStream bos = 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);
                DeepProtoType deepProtoType = (DeepProtoType) ois.readObject();
    
                return deepProtoType;
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            } finally {
                try {
                    ois.close();
                    bis.close();
                    oos.close();
                    bos.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
    
  • 测试

    @Slf4j
    public class Client {
        public static void main(String[] args) {
    
            DeepProtoType deepProtoType = new DeepProtoType("宋江", new DeepCloneableTarget("大牛", "小牛"));
    
            //方式1 完成深拷贝
    
    		DeepProtoType deepProtoType2 = deepProtoType.deepClone();
    
    		log.info("p.name=" + deepProtoType.getName() + "p.deepCloneableTarget=" + deepProtoType.deepCloneableTarget.hashCode());
    		log.info("p2.name=" + deepProtoType2.getName() + "p2.deepCloneableTarget=" + deepProtoType2.deepCloneableTarget.hashCode());
    
            deepProtoType.getDeepCloneableTarget().setCloneName("fsdf");
            log.info("p.name=" + deepProtoType.getDeepCloneableTarget() + "p.deepCloneableTarget=" + deepProtoType.deepCloneableTarget.hashCode());
            log.info("p2.name=" + deepProtoType2.getDeepCloneableTarget() + "p2.deepCloneableTarget=" + deepProtoType2.deepCloneableTarget.hashCode());
        }
    }
    

    测试可知深拷贝后的对象中的引用对象也是一片新的地址,修改原来的对象不影响拷贝的对象。

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

  • 创建新的对象比较复杂时,可以利用原型模式简化对象的创建过程,同时也能够提高效率
  • 不用重新初始化对象,而是动态地获得对象运行时的状态
  • 如果原始对象发生变化(增加或者减少属性),其它克隆对象的也会发生相应的变化, 无需修改代码
  • 在实现深克隆的时候可能需要比较复杂的代码

缺点:需要为每一个类配备一个克隆方法,这对全新的类来说不是很难,但对已有的类进行改造时,需要修改其源代码,违背了ocp原则文章来源地址https://www.toymoban.com/news/detail-516102.html

到了这里,关于设计模式篇(Java):原型模式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java设计模式-原型模式(3)

         馆长准备了很多学习资料,其中包含 java方面,jvm调优,spring / spring boot /spring cloud ,微服务,分布式,前端,js书籍资料,视频资料,以及各类常用软件工具,破解工具 等资源。请关注“IT技术馆”公众号,进行关注,馆长会每天更新资源和更新技术文章等。请大家多

    2024年01月21日
    浏览(44)
  • Java原型设计模式

    Java原型模式(Prototype Pattern)是一种创建型设计模式,它允许通过复制现有对象来创建新的对象,而无需显式地指定它们的类。这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时,则采用这种模式。例如,一个对象需要在一个

    2024年02月13日
    浏览(40)
  • 《Java极简设计模式》第05章:原型模式(Prototype)

    作者:冰河 星球:http://m6z.cn/6aeFbs 博客:https://binghe.gitcode.host 文章汇总:https://binghe.gitcode.host/md/all/all.html 源码地址:https://github.com/binghe001/java-simple-design-patterns/tree/master/java-simple-design-prototype 沉淀,成长,突破,帮助他人,成就自我。 本章难度:★★☆☆☆ 本章重点:用

    2024年02月11日
    浏览(43)
  • Java设计模式之创建型-原型模式(UML类图+案例分析)

    目录 一、基础概念 二、UML类图 三、角色设计 四、案例分析  4.1、通用实现(浅克隆) 4.2、深克隆 五、总结 原型模式通过复制已有对象作为原型,通过复制该原型来返回一个新对象,而不是新建对象,说白了就是不断复制相同的对象罢了。 角色 描述 抽象原型类 规定了具

    2024年02月15日
    浏览(49)
  • 【java设计模式】创建型模式介绍(工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式)

    简介 本文介绍Java设计模式中创建型模式的五种 一、工厂模式 工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 工厂模式提供了一种将对象的实例化过程封装在工厂类中的方式。通过使用工

    2024年02月16日
    浏览(47)
  • [设计模式Java实现附plantuml源码~创建型] 对象的克隆~原型模式

    前言: 为什么之前写过Golang 版的设计模式,还在重新写 Java 版? 答:因为对于我而言,当然也希望对正在学习的大伙有帮助。Java作为一门纯面向对象的语言,更适合用于学习设计模式。 为什么类图要附上uml 因为很多人学习有做笔记的习惯,如果单纯的只是放一张图片,那

    2024年01月23日
    浏览(42)
  • 【设计模式——学习笔记】23种设计模式——原型模式Prototype(原理讲解+应用场景介绍+案例介绍+Java代码实现)

    原型模式指用通过拷贝原型实例创建新的实例,新实例和原型实例的属性完全一致 原型模式是一种创建型设计模式 工作原理是通过调用原型实例的 clone() 方法来完成克隆,原型实例需要实现Cloneable接口,并重写 clone() 方法 需要为每个类开发一个克隆方法,这对全新的类来说

    2024年02月16日
    浏览(52)
  • 【原型设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

    原型模式(Prototype Pattern)是一种创建型设计模式,使你能够复制已有对象,而无需使代码依赖它们所属的类,同时又能保证性能。 这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时,则采用这种模式。 如果你需要复制一些对

    2023年04月24日
    浏览(84)
  • 二十三种设计模式全面解析-原型模式进阶之原型管理器:集中管理对象原型的设计模式之道

    在软件开发中,我们经常需要创建和复制对象。然而,有时候直接创建对象可能会导致性能下降或代码重复。为了解决这些问题,原型模式应运而生。而使用原型管理器(Prototype Manager)来集中管理原型对象可以进一步提高灵活性和可维护性。本文将详细介绍原型管理器的用

    2024年02月07日
    浏览(57)
  • 设计模式-原型模式详解

    简介设计模式 设计模式是在软件开发中常见问题的解决方案,它们是经过实践和经验总结出来的可重用的设计思想和解决方案。设计模式通过提供通用的架构、原则和指导,帮助开发人员更有效地编写高质量的代码。 设计模式分为三个主要类别: 创建型模式:关注对象的创

    2024年02月10日
    浏览(36)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包