扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >一文带你了解Java设计模式之原型模式
  • 392

0
分享到

一文带你了解Java设计模式之原型模式

2024-04-02 19:04:59 392人浏览 八月长安

Python 官方文档：入门教程 => 点击学习

摘要

目录定义解决的问题核心要点类图浅复制与深复制的区别代码实现未使用设计模式实现Cloneable接口深复制-重写clone深复制-通过对象序列化实现（推荐）拓展定义 用原型实例指定创建

定义

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

原型模式其实就是从一个对象在创建另外一个可定制的对象，不需要知道任何创建的细节

解决的问题

在运行期建立和删除原型。

经常用于：

类初始化消耗资源较多

构造函数比较复杂

核心要点

1.实现cloneable 接口，重写Object的clone方法

2.利用已有的一个原型对象，快速地生成和原型对象一样的实例。

类图

浅复制与深复制的区别

浅复制：基本数据类型进行值传递、引用数据类型的指针仍是指向原来的对象（成员变量）。

深复制：基本数据类型进行值传递、引用数据类型开辟新的内存空间。

代码实现

需求：实现克隆羊

有一头羊，需要经过赋值再克隆出两头。

未使用设计模式


public class Sheep {

    private String name;

    private Integer age;

    private String color;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public Sheep() {
    }

    public Sheep(String name, Integer age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }
}

Main方法


public class Client {

    public static void main(String[] args) {
        //小羊
        Sheep sheep=new Sheep("小红",8,"红色");
        //克隆羊
        Sheep sheep2=sheep;
        Sheep sheep3=sheep;

        System.out.println("通过赋值，指针还是指向sheep");
        System.out.println(sheep);
        System.out.println(sheep2);
        System.out.println(sheep3);
        
    }

}

//通过赋值，指针还是指向sheep
//com.promsing.creational.prototype.type1.Sheep@1b6d3586
//com.promsing.creational.prototype.type1.Sheep@1b6d3586
//com.promsing.creational.prototype.type1.Sheep@1b6d3586

实现Cloneable接口

Cloneable是标记型的接口，它们内部都没有方法和属性，实现 Cloneable来表示该对象能被克隆，能使用Object.clone()方法。

如果没有实现 Cloneable的类对象调用clone()就会抛出CloneNotSupportedException。

实现Cloneable默认是浅复制


public class Sheep implements Cloneable {

    private String name;

    private Integer age;

    private String color;

    
    private Sheep friend;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public Sheep() {
    }

    public Sheep getFriend() {
        return friend;
    }

    public void setFriend(Sheep friend) {
        this.friend = friend;
    }

    public Sheep(String name, Integer age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }


    
    @Override
    protected Sheep clone() {

        Sheep sheep = null;
        try {
            sheep = (Sheep) super.clone();

        } catch (CloneNotSupportedException e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
        return sheep;
    }
}

Main方法


public class ShallowClient {

    public static void main(String[] args) {

        Sheep sheep=new Sheep("小红",9,"红色");
        sheep.setFriend(new Sheep("小黑",10,"黑色"));
        Sheep sheep1 = sheep.clone();//开辟了新的空间
        Sheep sheep2 = sheep.clone();

        //浅复制
        System.out.println("原型羊"+sheep);
        System.out.println("克隆羊"+sheep1+"-朋友羊-"+sheep1.getFriend());
        System.out.println("克隆羊"+sheep2+"-朋友羊-"+sheep2.getFriend());
        
//原型羊com.promsing.creational.prototype.type3.Sheep@1b6d3586
//克隆羊com.promsing.creational.prototype.type3.Sheep@4554617c-朋友羊-com.promsing.creational.prototype.type3.Sheep@74a14482
//克隆羊com.promsing.creational.prototype.type3.Sheep@1540e19d-朋友羊-com.promsing.creational.prototype.type3.Sheep@74a14482


    }

}

一定要实现接口cloneable 否则报错：

Exception in thread "main" java.lang.CloneNotSupportedException: com.promsing.creational.prototype.type4.Sheep
    at java.lang.Object.clone(Native Method)
    at com.promsing.creational.prototype.type4.Sheep.clone(Sheep.java:76)
    at com.promsing.creational.prototype.type4.DeepClient.main(DeepClient.java:14)

深复制-重写clone

羊类、房子类都需要实现Cloneable接口

房子类


public class House implements Cloneable {

    //地址
    private String address;

    //尺寸
    private Integer size;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public Integer getSize() {
        return size;
    }

    public void setSize(Integer size) {
        this.size = size;
    }


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

羊类


public class Sheep implements  Cloneable {

    private String name;

    private Integer age;

    private String color;

    
    private House house;

    public House getHouse() {
        return house;
    }

    public void setHouse(House house) {
        this.house = house;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public Sheep() {
    }


    public Sheep(String name, Integer age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    
    @Override
    protected Object clone() throws CloneNotSupportedException {

        //对基本数据类型进行处理
        Sheep deep = null;
        deep = (Sheep) super.clone();

        //对引用类型进行处理
        //进行再次克隆
        House clone = (House) deep.getHouse().clone();
        deep.setHouse(clone);

        return deep;
    }

   
}

Main


public class DeepClient {

    public static void main(String[] args) throws CloneNotSupportedException {
        Sheep sheep=new Sheep("黑",90,"heisee");
        sheep.setHouse(new House());
        Sheep clone = (Sheep)sheep.clone();
        System.out.println("原本的对象");
        System.out.println(sheep);
        System.out.println(sheep.getHouse());
        System.out.println("克隆的对象");
        System.out.println(clone);
        System.out.println(clone.getHouse());
        
        
        //开辟了新的内存空间
        //原本的对象
        //com.promsing.creational.prototype.type4.Sheep@1b6d3586
        //com.promsing.creational.prototype.type4.House@4554617c
        //克隆的对象
        //com.promsing.creational.prototype.type4.Sheep@74a14482
        //com.promsing.creational.prototype.type4.House@1540e19d
    }

}

深复制-通过对象序列化实现（推荐）

羊类、房子类都需要实现Serializable接口。注意这里可以不实现Cloneable了。

房子类


public class House implements Serializable{

    //地址
    private String address;

    //尺寸
    private Integer size;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public Integer getSize() {
        return size;
    }

    public void setSize(Integer size) {
        this.size = size;
    }

}

羊类


public class Sheep implements Serializable {

    private String name;

    private Integer age;

    private String color;

    
    private House house;

    public House getHouse() {
        return house;
    }

    public void setHouse(House house) {
        this.house = house;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public Sheep() {
    }


    public Sheep(String name, Integer age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

 
    
    public 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);
            Sheep copyObj = (Sheep) ois.readObject();

            return copyObj;

        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
            return null;
        } finally {
            //关闭流
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (Exception e2) {
                // TODO: handle exception
                System.out.println(e2.getMessage());
            }
        }

    }
}

Main


public class DeepClient {

    public static void main(String[] args) throws CloneNotSupportedException {
        Sheep sheep=new Sheep("黑",90,"heisee");
        sheep.setHouse(new House());
        Sheep clone = (Sheep)sheep.deepClone();
        System.out.println("原本的对象");
        System.out.println(sheep);
        System.out.println(sheep.getHouse());
        System.out.println("克隆的对象");
        System.out.println(clone);
        System.out.println(clone.getHouse());
    }

}

拓展

spring使用原型模式：@scope(“prototype”)

public static void main(String[] args) throws IOException {
      //new一个容器
    AnnotationConfigWEBApplicationContext context =
        new AnnotationConfigWebApplicationContext();
    System.out.println("run success");

    OrderService bean = context.getBean(OrderService.class);
}

//根据getBean点进去
public <T> T getBean(Class<T> requiredType) throws BeansException {
		assertBeanFactoryActive();
		return getBeanFactory().getBean(requiredType);
}

public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
}

后续走到了。AbstractBeanFactory类中的doGetBean方法中里边代码做判断mbd.isPrototype()

protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {

		String beanName = transfORMedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually reGIStered singletons.
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			//代码省略~~~~
		}

		else {
			//代码省略~~~~

			
			try {
				//代码省略~~~~
                
				// Create bean instance.
                //判断是否是单例
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							
							destroySingleton(beanName);
							throw ex;
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
                //判断是否是多例（原型）
                //这里会创建一个新的对象
				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);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				else {
					//代码省略~~~~
				}
			}
			catch (BeansException ex) {
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
		}

		//代码省略~~~~
		}
		return (T) bean;
	}

ArrayList实现了Cloneable接口

public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
}

到此这篇关于一文带你了解Java设计模式之原型模式的文章就介绍到这了,更多相关Java原型模式内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

--结束END--

本文标题: 一文带你了解Java设计模式之原型模式

本文链接: https://lsjlt.com/news/166761.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • 一文带你了解Java设计模式之原型模式
    目录定义解决的问题核心要点类图浅复制与深复制的区别代码实现未使用设计模式实现Cloneable接口深复制-重写clone深复制-通过对象序列化实现（推荐）拓展定义 用原型实例指定创建...
    99+
    2024-04-02
  • 一文带你了解Java创建型设计模式之原型模式
    目录原型模式概述优缺点应用场景主要角色原型模式的基本使用创建原型接口创建具体需要克隆对象使用JDK自带原型接口的使用浅克隆与深度克隆浅克隆深度克隆单例的破坏原型模式 概述 原型模式(...
    99+
    2024-04-02
  • JAVA设计模式---原型模式你了解吗
    目录介绍角色Java语言提供的clone()方法代码演示—克隆羊结论深浅拷贝深浅拷贝探讨实现深克隆的方式一 ： 手动对引用对象进行克隆实现深克隆的方式二 ：序列化原型模式对单例模式的...
    99+
    2024-04-02
  • Java设计模式之原型模式详解
    目录一、前言二、优点及适用场景三、原型模式的注意事项四、浅复制和深复制五、浅复制demo演示六、深复制demo演示一、前言 原型模式是一种比较简单的模式，也非常容易理解，实现一个接口...
    99+
    2024-04-02
  • Java设计模式之java原型模式详解
    目录介绍角色Java语言提供的clone()方法代码演示—克隆羊结论深浅拷贝深浅拷贝探讨实现深克隆的方式一 ： 手动对引用对象进行克隆实现深克隆的方式一 ：序列化原型模式对单例模式的...
    99+
    2024-04-02
  • 深入理解Java设计模式之原型模式
    目录一、前言二、什么是原型模式三、原型模式的适用场景四、原型模式的实现1.浅拷贝实现2.深拷贝实现五、总结一、前言 单例模式可以避免重复创建消耗资源的对象，但是却不得不共用对象。若是...
    99+
    2024-04-02
  • java设计模式--原型模式详解
    目录引例原型模式浅拷贝在原先Sheep类基础上实现Cloneable接口，重写clone方法。客户端调用Sheep类新添的Cow类客户端调用克隆深拷贝1.Cow类也实现Cloneab...
    99+
    2024-04-02
  • Java设计模式之原型模式的示例详解
    目录定义案例需求方案一方案二对比分析总结 定义 用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象 即实现了一个原型接口，该接口用于创建当前对象的克隆，当直接创建对象的代...
    99+
    2024-04-02
  • java设计模式:原始模型模式
    目录什么是原始模型模式原始模型模式中的角色抽象原型角色（Prototype）具体原型角色（ConcretePrototype）A...
    99+
    2024-04-02
  • Java 深入理解创建型设计模式之原型模式
    1.思考问题 现在有一只羊 tom，姓名为: tom，年龄为:1，颜色为:白色，请编写程序创建和 tom羊属性完全相同的10只羊。 按照传统的思路来，我们可能会按照下面的方式去写。 ...
    99+
    2024-04-02
  • Java 超详细讲解设计模式之原型模式讲解
    目录传统方式原型模式基本介绍原型模式在spring框架中源码分析深入讨论-浅讨论和深拷贝原型模式的注意事项和细节传统方式 克隆羊问题 现在有一只羊 tom，姓名为: tom，年龄为:...
    99+
    2024-04-02
  • Java设计模式中的原型模式讲解
    目录介绍原型模式深拷贝与浅拷贝原型模式代码总结介绍 原型模式 在Java中,原型模式是一种创建型设计模式,它允许通过复制一个现有对象来创建一个新对象,而不是通过创建新的对象来初始化一...
    99+
    2023-05-18
    Java 原型设计模式 Java 设计模式 Java 原型模式
  • Java设计模式之原型设计示例详解
    目录简单说一下（定义）稍微夸一下（优缺点）顺便提一下（适用场景）着重讲一下（深、浅克隆）多多用一下（结构、代码实现）简单说一下（定义） 什么是原型模式：原型模式是用于创建重复的对象，...
    99+
    2024-04-02
  • Golang设计模式之原型模式详细讲解
    目录原型模式概念示例原型模式 原型是一种创建型设计模式， 使你能够复制对象， 甚至是复杂对象， 而又无需使代码依赖它们所属的类。 所有的原型类都必须有一个通用的接口， 使得即使在对象...
    99+
    2023-01-11
    Go原型模式 Go设计模式
  • Android常用设计模式之原型模式详解
    目录前言一、基本使用二、对象与集合的使用三、浅拷贝与深拷贝四、Kotlin的应用总结前言 什么是原型模式？ 它是指创建对象的种类，并通过拷贝这些原型创建新的对象。 它是用于创建重复的...
    99+
    2022-11-13
    Android 设计模式原型模式 Android 原型模式
  • Javascript设计模式之原型模式详细
    目录1、原型模式示例一示例二示例三2、观察者模式1、原型模式 原型模式用于在创建对象时，通过共享某个对象原型的属性和方法，从而达到提高性能、降低内存占用、代码复用的效果。 示例一 ...
    99+
    2024-04-02
  • JavaScript设计模式之原型模式详情
    目录前言案例回顾原型的拓展前言 设计模式呢最多的可能是用到类，我们去通过类来封装一些实用的方法，通过设计模式去实现各个方法之间的解耦等，由于JS中的继承是用原型链继承的，所以原型模式...
    99+
    2024-04-02
  • Java 深入探讨设计模式之原型模式篇
    目录传统方式原型模式基本介绍原型模式在spring框架中源码分析深入讨论-浅讨论和深拷贝原型模式的注意事项和细节传统方式 克隆羊问题 现在有一只羊 tom，姓名为: tom，年龄为:...
    99+
    2024-04-02
  • 深入了解Java行为型设计模式之策略模式
    目录策略模式应用场景优缺点主要角色策略模式的基本使用创建抽象策略角色创建具体策略角色创建上下文角色客户端执行策略模式实现支付方式的选择创建抽象策略角色创建具体策略角色创建上下文角色客...
    99+
    2024-04-02
  • .Net创建型设计模式之原型模式（Prototype）
    目录一、动机（Motivation）二、意图（Intent）三、结构（Structure）四、模式的组成五、 原型模式的具体实现六、原型模式的实现要点：1、原型模式的优点：2、原型模...
    99+
    2024-04-02
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作