设计模式篇(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设计模式之 - 原型模式

    原型模式是一种创建型设计模式,它允许我们通过克隆现有对象来创建新对象,而无需从头开始构建对象。 在该模式中,一个原型对象被克隆来生成新的对象,新对象的属性可以根据原型对象来设置,也可以进行修改。 原型模式主要解决的问题是对象的创建成本过高或者对

    2024年02月16日
    浏览(34)
  • Java原型设计模式

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

    2024年02月13日
    浏览(38)
  • 《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日
    浏览(40)
  • Java设计模式之创建型-原型模式(UML类图+案例分析)

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

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

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

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

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

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

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

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

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

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

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

    2024年02月07日
    浏览(56)
  • 重温设计模式 --- 原型模式

    原型模式 是一种创建型设计模式,它允许我们创建一个对象的副本,而不需要显式地使用构造函数来创建一个新的对象。这种模式通常用于创建那些具有复杂创建过程或需要大量资源的对象。 在原型模式中,我们首先定义一个原型接口,该接口包含一个克隆方法。然后我们

    2024年02月13日
    浏览(49)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包