JAVA设计模式—原型模式笔记

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

问题：clone 一个 Car 对象 ，clone 多次。

1.传统模式：

直接通过 new 的方式创建多个 Car 对象，创建的时候把原来 Car 对象的属性赋给新的对象。

//实体类
public class Car {
    private String name;
    private String color;
    private int size;

    public Car() {
    }

    public Car(String name, String color, int size) {
        this.name = name;
        this.color = color;
        this.size = size;
    }

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

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

    public int getSize() {
        return size;
    }

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

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", size=" + size +
                '}';
    }
}
//测试类
public class TradTest {
    public static void main(String[] args) {
        Car car = new Car("大众","黑色",18);
        //1.传统模式复制对象
        Car car1 = new Car(car.getName(),car.getColor(),car.getSize());
        Car car2 = new Car(car.getName(),car.getColor(),car.getSize());
        Car car3 = new Car(car.getName(),car.getColor(),car.getSize());
        System.out.println(car1);
        System.out.println(car2);
        System.out.println(car3);
    }
}

传统模式的优缺点：

  1. 优点是很好理解，代码简单
  2. 创建新对象时，总是抓取原对象的属性，如果对象复杂，效率会很低
  3. 总是需要重新初始化对象，而不是动态地获得对象运行时的状态, 不够灵活

2.原型模式

原型模式介绍：

  1. 原型模式(Prototype 模式)是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象
  2. 原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节
  3. 工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即 对象.clone()

2.1 使用原型模式改进传统方式，让程序具有更高的效率和扩展性。

对象实体类需要实现 Cloneable 接口，并且重写 clone() 方法。

//实体类 Car
public class Car implements Cloneable{
    private String name;
    private String color;
    private int size;
    public Country country;

    public Car() {
    }

    public Car(String name, String color, int size) {
        this.name = name;
        this.color = color;
        this.size = size;
    }

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

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

    public int getSize() {
        return size;
    }

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

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", size=" + size +
                ", country=" + country +
                '}';
    }

    @Override
    public Object clone() {
        Car car = null;
        try{
            car = (Car) super.clone();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return car;
    }
}
//实体类 Country ，Car 类的属性包含该对象
public class Country implements Cloneable{
    private String name;

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

    public String getName() {
        return name;
    }

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

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

    @Override
    public Object clone() {
        Country country = null;
        try {
            country = (Country) super.clone();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return country;
    }
}
//测试类
public class SimpleCopy {
    public static void main(String[] args) {
        //2.浅拷贝复制对象
        Car c1 = new Car("大众","黑色",18);
        c1.country = new Country("德国");
        Car c2 = (Car) c1.clone();
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c1.country.hashCode());
        System.out.println(c2.country.hashCode());
    }
}

2.2 浅拷贝和深拷贝

2.2.1 浅拷贝介绍

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

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

3.上面的案例就是浅拷贝，浅拷贝使用默认的 clone() 方法实现。如果我们修改 c2 的 country 属性的数据，那么 c1 的 country 数据也会随之改变。

2.2.2 深拷贝介绍

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

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

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

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

2.2.3 重写 clone() 方法实现深拷贝

//Car 实体类
public class Car implements Cloneable{
    private String name;
    private String color;
    private int size;
    public Country country;

    public Car() {
    }

    public Car(String name, String color, int size) {
        this.name = name;
        this.color = color;
        this.size = size;
    }

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

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

    public int getSize() {
        return size;
    }

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

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", size=" + size +
                ", country=" + country +
                '}';
    }

    @Override
    public Object clone() {
        Car car = null;
        try{
            car = (Car) super.clone();
            car.country = (Country) car.country.clone();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return car;
    }
}
//Country 实体类
public class Country implements Cloneable{
    private String name;

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

    public String getName() {
        return name;
    }

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

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

    @Override
    public Object clone() {
        Country country = null;
        try {
            country = (Country) super.clone();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return country;
    }
}
//测试类
public class DeepCopy1 {
    public static void main(String[] args) {
        //1.深拷贝方式一：重写clone()
        Car car = new Car("五菱","红色",18);
        car.country = new Country("中国");
        Car clone = (Car) car.clone();
        System.out.println(car);
        System.out.println(clone);
        System.out.println(car.country.hashCode());
        System.out.println(clone.country.hashCode());
    }
}

2.2.4 通过序列化实现深拷贝

public class Car implements Serializable,Cloneable {
    private static final long serialVersionUID = 54645442L;
    private String name;
    private String color;
    private int size;
    public Country country;

    public Car() {
    }

    public Car(String name, String color, int size) {
        this.name = name;
        this.color = color;
        this.size = size;
    }

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

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

    public int getSize() {
        return size;
    }

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

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", size=" + size +
                ", country=" + country +
                '}';
    }

    //自定义克隆方法
    public Car cloneCar() {
        Car car = null;
        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);
            car = (Car) ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                ois.close();
                bis.close();
                oos.close();
                bos.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return car;
    }
}
public class Country implements Serializable, Cloneable{
    private static final long serialVersionUID = 34545442L;
    private String name;

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

    public String getName() {
        return name;
    }

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

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

    @Override
    public Object clone() {
        Country country = null;
        try {
            country = (Country) super.clone();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return country;
    }
}
public class DeepCopy2 {
    public static void main(String[] args) {
        //2.深拷贝方式二：实现序列化
        Car car = new Car("五菱","红色",18);
        car.country = new Country("中国");
        Car clone = car.cloneCar();
        System.out.println(car);
        System.out.println(clone);
        System.out.println(car.country.hashCode());
        System.out.println(clone.country.hashCode());
    }
}

2.3 原型模式注意事项

  1. 创建新的对象比较复杂时，可以用原型模式简化对象的创建过程，能够提高效率
  2. 不用重新初始化对象，而是动态地获得对象运行时的状态
  3. 原始对象发生变化(增加或者减少属性)，其它克隆对象的也会发生相应的变化，不用修改代码
  4. 在实现深拷贝时可能需要比较复杂的代码
  5. 缺点：需要为每一个类配备一个clone() 方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了 ocp 原则。
心碎de梦魇
关注
专栏目录
韩顺平_Java设计模式笔记.docx
05-20
本资源摘要信息是对《韩顺平_Java设计模式笔记.docx》的总结和分析，该笔记涵盖了 Java 设计模式的基础知识、设计模式的七大原则、原型设计模式、解释器设计模式、单例设计模式等内容，并对每个设计模式的原理、实现...
韩顺平_java设计模式笔记
11-07
Java设计模式是软件开发中的一种最佳实践，它们是为了解决特定场景下的设计问题而发展起来的。23种设计模式被广泛应用于提高代码的可重用性、可读性、可维护性和灵活性。韩顺平老师的Java设计模式课程通过生活中的...
一、本周主要复习下设计模式(08-24 ~ 08-30)
码Nong
08-25 108
本周主攻复习设计模式： 设计的6大原则、7大原则(SOLID) 单一职责原则 开闭原则 依赖倒置原则 里式替换原则 接口隔离原则 迪米特原则 设计模式 创建型 结构型 行为型 J2EE模式
【Java笔记+踩坑】设计模式——原型模式
vincewm的博客
10-26 514
对比原型模式和传统方式的实现思路、代码方案、优缺点，阐述原型模式的使用场景，以及深拷贝、浅拷贝等相关概念，并扩展原型模式在Spring源码中的应用。
黑马程序员java设计模式笔记
Vashon的博客
12-11 1786
分类 创建者模式 结构型模式 行为型模式 2 类图 UML 2.1 类图概述 显示了模型的静态结构 2.2 类图表示法 2.2.1 类的表示方式 Demo + age:int + method(args 1):int +:public -:private #:protected 属性完整表示 可见性 名称：类型 方法完整表示： 可见性 名称（参数列表）[:返回类型] 2.2.2 类与类之间关系的表示方式 2.2.2.1 关联关系 1.单向关联 一个顾客有一个地址 2.双向.
JAVA设计模式——【原型模式】
2401_86352702的博客
09-01 2136
Java架构进阶面试及知识点文档笔记这份文档共498页，其中包括Java集合，并发编程，JVM，Dubbo,Redis，Spring全家桶，MySQL，Kafka等面试解析及知识点整理Java分布式高级面试问题解析文档其中都是包括分布式的面试问题解析，内容有分布式消息队列，Redis缓存，分库分表，微服务架构，分布式高可用，读写分离等等！互联网Java程序员面试必备问题解析及文档学习笔记Java架构进阶视频解析合集来实现深拷贝④深拷贝实现方式2:通过对象序列化实现深拷贝(推荐)深拷贝应用案例;
Java设计模式——原型模式
Lu君的博客
05-11 308
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。 以某个对象为原型进行克隆再进行加工修改。 创建复杂对象时，提高效率。 优点： 性能提高。 逃避构造函数的约束。 缺点： 配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。 使用场景： 类初始化非常复杂，需要大量资源。 一个对象多个修改者的场景。 原型模式很少单独使用，一般是和工厂模式一起使用，通过 cl
Java常见设计模式
WZX17307935391的博客
09-01 2393
Java的常见设计模式
java设计模式笔记
penanut的博客
04-20 1490
根据黑马程序员的课程资料整理所得，仅用于学习使用，如有侵权，请联系删除。 1，设计模式概述 1.1 软件设计模式的产生背景 "设计模式"最初并不是出现在软件设计中，而是被用于建筑领域的设计中。 1977年美国著名建筑大师、加利福尼亚大学伯克利分校环境结构中心主任克里斯托夫·亚历山大（Christopher Alexander）在他的著作《建筑模式语言：城镇、建筑、构造》中描述了一些常见的建筑设计问题，并提出了 253 种关于对城镇、邻里、住宅、花园和房间等进行设计的基本模式。 1990年软件工程界开始研讨设
黑马-设计模式-笔记（未完）
一个记录积累的地方
04-25 902
自己的笔记，大佬勿喷
学习笔记：java的23种设计模式总结
m0_63246220的博客
07-10 1426
学习笔记
设计模式笔记02(java版)
weixin_46425661的博客
08-21 948
重点讲述创建者模式中的单例模式、工厂方法模式、原型模式、建造者模式
图解Java设计模式笔记总结word版本.rar
06-29
本资料“图解Java设计模式笔记总结word版本”聚焦于通过图文并茂的方式，深入浅出地解析各种设计模式。以下是基于这个主题的详细知识点讲解： 1. **设计模式的分类** - **创建型模式**：如单例（Singleton）、工厂...
Java设计模式学习笔记.pdf
06-13
在学习Java设计模式时，掌握其概念、应用、优点和缺点非常重要。设计模式是软件开发中经常使用的一种通用解决方案模板，用于解决特定上下文中的常见问题。它们源于设计模式的研究，通常被认为是软件设计中的最佳实践...
23种设计模式具体实现方法
晴山の博客
10-16 492
前期疑问：适配器模式的优点主要包括：（1）提高类的透明性和复用性： 适配器模式可以让类在现有的基础上进行复用，而不需要做出任何改变，这有助于避免大规模改写现有代码。（2）解耦目标类和适配器类： 通过使用适配器模式，目标类和适配器类可以实现解耦，从而提高程序的扩展性。这符合开闭原则，即对扩展开放，对修改关闭。（3）更好的扩展性： 在实现适配器功能的时候，可以调用自己开发的功能，从而自然地扩展系统的功能。（4）灵活性好： 适配器并没有影响原有功能，如果不想使用，可以直接删除。
代理设计模式
2301_80220193的博客
10-14 1324
二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。就拿日志功能来说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代码，日志功能还是分散的，没有统一管理。它是一种设计模式，用于在不修改原始对象的情况下，通过代理对象来间接访问原始对象，并在访问前后执行额外的操作。
设计模式，面试级别的详解(持续更新中)
最新发布
qq_51321722的博客
10-16 414
其实很简单，第一重判断，如果实例已经存在，那么就不再需要进行同步操作，而是直接返回这个实例，如果没有创建，才会进入同步块，同步块的目的与之前相同，目的是为了防止有多个线程同时调用时，导致生成多个实例，有了同步块，每次只能有一个线程调用访问同步块内容，当第一个抢到锁的调用获取了实例之后，这个实例就会被创建，之后的所有调用都不会进入同步块，直接在第一重判断就返回了单例。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。，这种方式比较常用，但容易产生垃圾对象，浪费内存空间。
设计模式02-桥接模式(Java)
XYX_888的博客
10-13 504
它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。在使用关联关系是，及在抽象类引入实现类接口时可能会出现不适配的情况，这是可以用适配器类型将其转换成抽象类可以适配的类进行关联。扩展抽象化角色 ：是抽象化角色的子类，实现父类中的业务方法， 并通过组合关系调用实现化角色中的业务方法。实现化角色 ：定义实现化角色的接口，供扩展抽象化角色调用。抽象化角色 ：定义抽象类，并包含一个对实现化对象的引用。具体实现化角色 ：给出实现化角色接口的具体实现。实现了对抽象和实现之间的解耦。
【UML】一个UML学习的还不错的几个帖子
qq_36634055的博客
10-16 248
https://segmentfault.com/a/1190000042775634
Java设计模式面试题与源码分享
资源摘要信息: "本资源分享包含Java设计模式相关的面试题及其源码，覆盖了常见的设计模式知识点，适合求职者在面试前进行复习和加深理解。资源中包含了单例模式等多种模式的实现代码，有助于面试者更好地理解和掌握...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值