原型设计模式

最新推荐文章于 2025-12-20 14:00:42 发布
原创 最新推荐文章于 2025-12-20 14:00:42 发布 · 134 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#原型模式 #java #开发语言

原型模式

克隆羊问题

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

使用传统的方式的优缺点

1）优点时比较好理解，简单易操作。

2）在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低

3）总是需要重新初始化对象，而不是动态地获得对象运行时的状态，不够灵活

改进思路：在Java中Object类时所有类的基类，Object类提供了clone()方法，该方法可以将一个java类必须实现一个接口Cloneable,该接口表示该类能够复制且具有复制能力

原型模式-基本介绍

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

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

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

形象的理解：孙大圣拔猴毛，变出其它孙猴子

1、浅拷贝

浅拷贝的介绍

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

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

浅拷贝使用默认的clone()方法实现即可

package designPatterns.protoType.type1;


//实现Cloneable接口，重写clone方法
public class Sheep implements Cloneable{
    private String name;
    private int age;
    private String color;
    public Sheep(){

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

    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 String getColor() {
        return color;
    }

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

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

    //重写clone方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        //浅拷贝
        return super.clone();
    }
}


package designPatterns.protoType.type1;

public class TestMain {
    public static void main(String[] args) throws CloneNotSupportedException {
        Sheep sheep = new Sheep("绵阳", 19, "白色");
        Sheep clone = (Sheep) sheep.clone();
        Sheep clone1 = (Sheep) sheep.clone();
        Sheep clone2 = (Sheep) sheep.clone();
        Sheep clone3 = (Sheep) sheep.clone();
        System.out.println(clone);
        System.out.println(clone1);
        System.out.println(clone2);
        System.out.println(clone3);
    }
}

2、深拷贝

深拷贝基本介绍

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

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

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

package designPatterns.protoType.type2;

//轮胎
public class Tyre implements Cloneable{
    private String name;
    private int age;
    private String price;
    public Tyre(){

    }
    public Tyre(String name,int age,String price){
        this.name=name;
        this.age=age;
        this.price=price;
    }

    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 String getPrice() {
        return price;
    }

    public void setPrice(String price) {
        this.price = price;
    }

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

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



package designPatterns.protoType.type2;

public class Car implements Cloneable{
    private String type;
    private int age;
    private String price;
    private Tyre tyre;
    public Car(){

    }
    public Car(String type,int age,String price,Tyre tyre){
        this.type=type;
        this.age=age;
        this.price=price;
        this.tyre=tyre;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public int getAge() {
        return age;
    }

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

    public String getPrice() {
        return price;
    }

    public void setPrice(String price) {
        this.price = price;
    }

    public Tyre getTyre() {
        return tyre;
    }

    public void setTyre(Tyre tyre) {
        this.tyre = tyre;
    }

    @Override
    public String toString() {
        return "Car{" +
                "type='" + type + '\'' +
                ", age=" + age +
                ", price='" + price + '\'' +
                ", tyre=" + tyre +
                '}';
    }

    //深拷贝（对引用的属性在进行克隆）
    @Override
    protected Object clone() throws CloneNotSupportedException {
        //这里完成对基本数据类型和String类型进行clone
        Car carClone = (Car) super.clone();
        //对引用数据类型的属性，进行单独的clone
        carClone.tyre= (Tyre) this.tyre.clone();
        return carClone;
    }
}



package designPatterns.protoType.type2;

public class TestMain {
    public static void main(String[] args) throws CloneNotSupportedException {
        Car car = new Car("宝马", 19, "1888888", new Tyre("好轮胎", 19, "3999"));
        Car clone1 = (Car) car.clone();
        Car clone2 = (Car) car.clone();
        System.out.println(clone1==clone2);
        System.out.println(clone1.hashCode() +""+ clone1);
        System.out.println(clone2.hashCode() +""+ clone2);
    }
}

2、深拷贝（对象序列化）

通过对象序列化实现深拷贝

类实现Serializable接口和Cloneable接口

重写clone方法

package designPatterns.protoType.type3;

import java.io.Serializable;

//轮胎
public class Tyre implements Cloneable, Serializable {
    private String name;
    private int age;
    private String price;
    private static final long serialVersionUID = 1L;
    public Tyre(){

    }
    public Tyre(String name,int age,String price){
        this.name=name;
        this.age=age;
        this.price=price;
    }

    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 String getPrice() {
        return price;
    }

    public void setPrice(String price) {
        this.price = price;
    }

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

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


package designPatterns.protoType.type3;

import java.io.*;

public class Car implements Cloneable, Serializable {
    private String type;
    private int age;
    private String price;
    private Tyre tyre;
    private static final long serialServiceUID = 1L;

    public Car() {

    }

    public Car(String type, int age, String price, Tyre tyre) {
        this.type = type;
        this.age = age;
        this.price = price;
        this.tyre = tyre;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public int getAge() {
        return age;
    }

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

    public String getPrice() {
        return price;
    }

    public void setPrice(String price) {
        this.price = price;
    }

    public Tyre getTyre() {
        return tyre;
    }

    public void setTyre(Tyre tyre) {
        this.tyre = tyre;
    }

    @Override
    public String toString() {
        return "Car{" +
                "type='" + type + '\'' +
                ", age=" + age +
                ", price='" + price + '\'' +
                ", tyre=" + tyre +
                '}';
    }

    //深拷贝（使用序列化+对象流）
    @Override
    protected Object clone() throws CloneNotSupportedException {
        ByteArrayOutputStream bos = null;//字节输出流
        ObjectOutputStream ops = null;//对象输出流
        ByteArrayInputStream bis = null;//字节输入流
        ObjectInputStream ois = null;//对象输入流
        Car car = null;
        try {
            //对象序列化
            bos = new ByteArrayOutputStream();
            ops = new ObjectOutputStream(bos);
            ops.writeObject(this);
            //对象反序列化
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            car = (Car) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        } finally {
            //关闭流
            try {
                ois.close();
                bis.close();
                ops.close();
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return car;
    }
}

package designPatterns.protoType.type3;


public class TestMain {
    public static void main(String[] args) throws CloneNotSupportedException {
        Car car = new Car("宝马", 19, "1888888", new Tyre("好轮胎", 19, "3999"));
        Car clone1 = (Car) car.clone();
        Car clone2 = (Car) car.clone();
        System.out.println(clone1==clone2);
        System.out.println(clone1.hashCode() +""+ clone1);
        System.out.println(clone2.hashCode() +""+ clone2);
    }
}

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

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

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

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

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

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

创意设计模式：原型设计模式
新华编程特战队
01-09 1401
原型设计模式是创建性设计模式之一。它允许我们指定作为原始对象原型的对象。换句话说，它允许我们复制现有对象而不是创建新实例。在这里，我们将详细了解原型设计模式及其用法。
设计模式——原型设计模式（创建型）
庄小焱
05-31 1290
本文详细介绍了原型设计模式，这是一种创建型设计模式，通过复制现有对象（原型）来创建新对象，避免使用new关键字，可提高性能并简化对象创建逻辑。文章阐述了其优点，如提高性能、动态扩展和简化构造逻辑，以及缺点，如深拷贝实现复杂、复杂资源复制困难和易破坏封装性。还介绍了使用条件、结构、实现方式、适合场景和实战示例，并探讨了Spring中原型思想的应用。
设计模式-原型设计模式
qq_41217095的博客
02-07 1354
传统的方式的优缺点优点是比较好理解，简单易操作在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低总是需要重新初始化对象，而不是动态地获得对象运行时的状态，不够灵活改进的思路分析思路:Java中Object类是所有类的根类，0biect类提供了一个cone()方法，该方法可以将一个Java对象复制一份，但是需要实现clone的Java类必须要实现一个接口Cloneable，该接口表示该类能够复制且具有复制的能力=>原型模式。
【设计模式】深入理解Python中的原型设计模式
h1773655323的博客
10-16 1786
通过复制现有对象来创建新的对象。原型模式在某种程度上是一种浅拷贝或深拷贝技术，通过复制一个对象的所有属性而无需重新执行构造函数。__copy__()
设计模式之原型模式
道可道非常道
08-08 1149
原型设计模式（Prototype Design Pattern）是一种创建型设计模式，其核心思想是通过复制（克隆）现有对象来创建新对象，而不是通过传统的实例化方式。这个模式在系统中需要创建大量相似对象时非常有用，可以避免反复创建同一类对象，并且在某些情况下还能提高性能。在原型模式中，对象实现一个原型接口，该接口规定了一个clone方法，用于返回对象自身的副本。这样，客户端就可以通过克隆的方式来创建对象，而不需要直接依赖具体类的构造函数。Prototype（原型接口）：定义一个用于克隆自身的接口。
设计模式-原型模式
qq_40840571的博客
09-07 3143
但是这种实现方法涉及到递归遍历的问题，也就是说如果parent下面还有指针对象，又或者parent的兄弟属性还有其他的指针对象，那么这种实现方法将会变得非常复杂。原型模式是一种创建对象的设计模式，主要通过复制现有对象来创建新对象，而不是通过实例化新对象的类。可以看到上面两种方法的实现，都需要类对象的首字母开头大写，这样可能会有参数泄漏的风险，下面可以看看反射的实现，比较复杂。可以看到在创建prototype对象的基础上，可以快速的初始化其他两个对象。如果不包含这类属性，是不会存在问题的。
设计模式之原型设计模式
qq_74811378的博客
09-01 1534
① 覆盖 clone 方法 ( 必须 ) : 必须重写对象的 clone 方法 , Java 中提供了 cloneable 标识该对象可以被拷贝 , 但是必须覆盖 Object 的 clone 方法才能被拷贝;② 流程简单 : 原型模式可以简化创建的过程 , 可以直接修改现有的对象实例的值 , 达到复用的目的;原型模式主要用于对象的复制，它的核心是就是类图中的原型类 Prototype。深拷贝是指当一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝。
C# 设计模式之原型模式
鲤籽鲲的博客
08-01 1299
C# 设计模式之原型模式
设计模式8——原型模式
weixin_43687024的博客
05-20 1222
1、用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象；2、可以从一个对象再创建另外一个可定制的对象，而且不需要知道任何的细节；3、不用重新初始化对象，而是动态地获得对象运行时得状态。待克隆的对象：也就是需要频繁被复制的对象，我们采用克隆的思想去复制他。或许会有疑问，这个模式不就是复制实例对象吗？着我手动代码就复制了，有必要专门讨论吗？和一般一行一行代码复制不一样，这个的理论是希望他能直接在内存里就复制过去，而不是我们再创建一片空间，然后把对象属性一个一个复制过去。
PHP设计模式之原型设计模式原理与用法分析
10-18
原型设计模式是软件设计模式中的一种创建型模式，它允许一个对象创建一个新对象，而无需指定其具体的类。原型模式的核心思想是通过复制一个已存在的实例来创建一个新的实例，而不是通过类的构造函数来完成。 在原型...
原型设计模式prototype
03-24
**原型设计模式(Prototype Pattern)**是一种创建型设计模式，它允许我们通过复制现有的对象来创建新对象，而不是通过构造函数来实例化新对象。在面向对象编程中，当我们需要频繁地创建具有相同或相似属性的对象时，...
Java原型设计模式(Prototype)
01-20
　原型模式(Prototype)是通过复制一个已经存在的实例来返回新的实例，而不是新建实例，被复制的实例是我们所称的原型对象，这个原型是可定制的。 　2、原理 　有两部分组成，抽象原型和具体原型。意图：用原型...
vue使用lodop控件打印
weixin_72329752的博客
12-19 350
通过以上步骤，即可在 Vue 项目中实现 Lodop 的打印功能。若需打印 Vue 渲染的动态内容，可通过。在 Vue 组件中，通过。
原型模式-创建型
冷崖的博客
12-20 310
原型模式摘要 原型模式通过复制现有对象（原型）来创建新对象，而非使用new实例化。核心思想是克隆机制，适用于需要高效创建大量相似对象的场景。以孙悟空分身为例，传统方式每次创建分身都需重新初始化技能和装备，存在性能低下、灵活性差和浅拷贝问题。原型模式解决方案包括：1）定义抽象原型类提供克隆接口；2）具体原型类实现深拷贝，确保装备等引用类型被正确复制。该模式显著提升对象创建效率，同时避免内存管理问题。
区分__proto__和prototype
编写博客，学习交流
12-17 649
prototype和__proto__是原型链的两大核心载体，但二者的归属、本质和目的截然不同，是理解原型链的第一道门槛。概念归属对象本质/类型存在的目的典型示例prototype只有函数（构造函数）普通对象（原型对象）存放“供所有实例继承的公共属性/方法”，是构造函数的“原型仓库”__proto__所有对象（包括函数）原型指针（内置访问器属性）连接实例与原型对象，是实例的“原型导航”，用于原型链查找（ES6 标准化，等价于维度prototype__proto__归属仅函数（构造函数）拥有。
Vue 中理解__proto__和prototype
编写博客，学习交流
12-17 972
概念在 Vue 中的作用prototype1.：存放所有 Vue 实例（vm/vc）的核心方法（emitemit、emitwatch 等）；2.：存放组件的自定义原型方法，且其__proto__指向；3. 可通过修改实现全局属性/方法注入。__proto__1. vm 的__proto__指向，继承核心方法；2. vc 的__proto__指向，再通过继承；3. 是实例查找原型链的「指针」，Vue 实例的所有内置方法都依赖它查找。prototype。
JS原型链总结
最新发布
2401_82484471的博客
12-20 754
原型链是 `JS` 实现**继承**的核心机制：当访问一个对象的属性 / 方法时，JS 引擎先在对象自身查找；若找不到，则通过 `[[Prototype]]` 向上查找其原型对象；若原型对象仍找不到，继续向上查找原型的原型，直到 `Object.prototype`；若最终仍未找到，返回 `undefined`（方法则报错 `xxx is not a function`）。这条由 `[[Prototype]]` 串联的链式结构，就是**原型链**。
vue3手机端列表加载组件
n1234567896的博客
12-18 908
摘要 本文介绍了一个适用于移动端的列表加载组件实现方案。该组件采用Vue 3开发，主要功能包括：分页加载数据、自定义加载提示文字、搜索功能和空状态处理。组件设计借鉴了Element Plus的v-infinite-scroll指令实现无限滚动加载，通过插槽机制允许自定义列表项渲染，并提供灵活的配置选项（如pageSize、loadingText等）。实现上包含数据请求处理、加载状态管理和下拉刷新功能，支持通过refresh方法重置数据。组件代码展示了核心模板结构和逻辑实现，包括列表渲染、加载提示和空状态显示
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值