java设计模式-07-原型工厂模式（克隆）

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

定义

  • 通过将一个原型对象传给要发动创建的对象，这个要发动的创建的对象通过请求原型对象了拷贝他们自己实现创建，即 对象.clone()
  • 用原型实例指定创建对象的种类，并且通过拷贝，创建新的对象
  • 缺点：需要为每一类配置一个克隆方法，对已有类改造，需修改源代码，违背了ocp原则

浅拷贝

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

三种代码实现方式

  • 通过拷贝构造方法实现浅拷贝：

public class test1 {
    public static void main(String[] args) {
        Age age= new Age(1);
        Person p1 = new Person(age, "小黄");
        Person p2 = new Person(p1);
        System.out.println("p1是"+p1.toString());
        System.out.println("p2是"+p2.toString());
        age.setAge(2);
//      age.setAge(new Age(2)); 这里创建了一个新的对象，就不会改变原来的对象了，数据就不会变动了
        p1.setName("小青");
        //String类型属于引用数据类型，不属于基本数据类型，但是String类型的数据是存放在常量池中的，
        //也就是无法修改的！也就是说，当我将name属性修改后，
        //并不是修改了这个数据的值，而是把这个数据的引用从指向”小黄“这个常量改为了指向”大小青“这个常量。在这种情况下，另一个对象的name属性值仍然指向”小黄“不会受到影响。
        System.out.println("修改后的p1是"+p1.toString());
        System.out.println("修改后的p2是"+p2.toString());
       /**
        p1是Person{age=age{age=1}, name='小黄'}
        p2是Person{age=age{age=1}, name='小黄'}
        修改后的p1是Person{age=age{age=2}, name='小青'}
        修改后的p2是Person{age=age{age=2}, name='小黄'}
        成功复制了吗，但是引用数据类型的数据变动了，如果如果在拷贝构造方法中，
        对引用数据类型变量逐一开辟新的内存空间，创建新的对象，或者使用深拷贝
        */
    }
}

class Person {
    //使用引用数据类型
    private Age age;
    //使用常量
    private String name;

    public Person(Age age, String name) {
        this.age = age;
        this.name = name;
    }

    public Person(Person p) {
        this.age = p.getAge();
        this.name = p.getName();
    }

    public Age getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
class Age{
    private int age;
public Age(int age){
    this.age=age;
}
    public int getAge() {
        return age;
    }

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

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

    @Override
    public String toString() {
        return "age{" +
                "age=" + age +
                '}';
    }
}

通过重写clone()方法进行浅拷贝：
Object类是类结构的根类，其中有一个方法为protected Object clone()，这个方法就是进行的浅拷贝。

	 1. Object类虽然有这个方法，但是这个方法是受保护的（被protected修饰），所以我们无法直接使用。
	 2. 使用clone方法的类必须实现Cloneable接口，否则会抛出异常CloneNotSupportedException。
	 3. 对于这两点，我们的解决方法是，在要使用clone方法的类中重写clone()方法，通过super.clone()调用Object类中的原clone方法。

代码


public class test1 {
    public static void main(String[] args) {
        Age age = new Age(1);
        Person p1 = new Person(age, "小黄");
        Person p2 = (Person) p1.clone();
        System.out.println("p1是" + p1.toString());
        System.out.println("p2是" + p2.toString());
          age.setAge(2);
//      age.setAge(new Age(2)); 这里创建了一个新的对象，就不会改变原来的对象了，数据就不会变动了
        p1.setName("小青");
        System.out.println("修改后的p1是" + p1.toString());
        System.out.println("修改后的p2是" + p2.toString());
    }
}

class Person implements Cloneable {//实现一个接口
    //使用引用数据类型
    private Age age;
    //使用常量
    private String name;

    public Person(Age age, String name) {
        this.age = age;
        this.name = name;
    }

    public Person(Person p) {
        this.age = p.getAge();
        this.name = p.getName();
    }

    public Age getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    //重写Object类的clone方法
    public Object clone() {
        Object obj = null;
        try {
            obj = super.clone();
        } catch (Exception e) {
            System.out.println("报错了：" + e);
        }
        return obj;
    }

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

class Age {
    private int age;

    public Age(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

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

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

    @Override
    public String toString() {
        return "age{" +
                "age=" + age +
                '}';
    }
}

深克隆：

  • 定义：简单地说，深拷贝对引用数据类型的成员变量的对象图中所有的对象都开辟了内存空间

通过重写clone方法来实现


public class test1 {
    public static void main(String[] args) {
        Age age = new Age(1);
        Person p1 = new Person(age, "小黄");
        Person p2 = (Person) p1.clone();
        System.out.println("p1是" + p1.toString());
        System.out.println("p2是" + p2.toString());
        // age.setAge(new Age(2));
        age.setAge(2);
        p1.setName("小青");
        System.out.println("修改后的p1是" + p1.toString());
        System.out.println("修改后的p2是" + p2.toString());
    }
}

class Person implements Cloneable {//实现一个接口
    //使用引用数据类型
    private Age age;
    //使用常量
    private String name;

    public Person(Age age, String name) {
        this.age = age;
        this.name = name;
    }

    public Person(Person p) {
        this.age = p.getAge();
        this.name = p.getName();
    }

    public Age getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    //重写Object类的clone方法
    public Object clone() {
        Object obj = null;
        try {
            obj = super.clone();
        } catch (Exception e) {
            System.out.println("报错了：" + e);
        }
        Person p = (Person) obj;
        p.setAge((Age) p.getAge().clone());//学生类实例的Age对象属性，调用其clone方法进行拷贝
        return obj;
    }

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

class Age implements Cloneable {
    private int age;

    public Age(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

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

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

    @Override
    public String toString() {
        return "age{" +
                "age=" + age +
                '}';
    }

    //重写Object的clone方法
    public Object clone() {
        Object obj = null;
        try {
            obj = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return obj;
    }
}

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

  • 虽然层次调用clone方法可以实现深拷贝，但是显然代码量实在太大。特别对于属性数量比较多、层次比较深的类而言，每个类都要重写clone方法太过繁琐。
  • 将对象序列化为字节序列后，默认会将该对象的整个对象图进行序列化，再通过反序列即可完美地实现深拷贝。
  • 注意的是，如果某个属性被transient修饰，那么该属性就无法被拷贝了

import java.io.*;

public class test1 {
    public static void main(String[] args)throws IOException, ClassNotFoundException {
        Age age = new Age(1);
        Person p1 = new Person(age, "小黄");
        Person p2 = (Person)serializations(p1);
        System.out.println("p1是" + p1.toString());
        System.out.println("p2是" + p2.toString());
        // age.setAge(new Age(2));
        age.setAge(2);
        p1.setName("小青");
        System.out.println("修改后的p1是" + p1.toString());
        System.out.println("修改后的p2是" + p2.toString());
    }

    public static  Object serializations(Object o1) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(o1);
        oos.flush();

        ObjectInputStream ois=new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
        return  ois.readObject();


    }
}


class Person implements Serializable {//实现一个接口
    //使用引用数据类型
    private Age age;
    //使用常量
    private String name;

    public Person(Age age, String name) {
        this.age = age;
        this.name = name;
    }

    public Person(Person p) {
        this.age = p.getAge();
        this.name = p.getName();
    }

    public Age getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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


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

class Age implements Serializable {
    private int age;

    public Age(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

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

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

    @Override
    public String toString() {
        return "age{" +
                "age=" + age +
                '}';
    }


}
程序员黄小青
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
克隆模式java_java基础之----23种设计模式（克隆模式）
weixin_30517215的博客
02-28 737
概述克隆模式是一种比较简单的设计模式，基本从字面意思就可以明白这种设计模式是干什么的，简单来说就是造一个和原来一模一样的对象，就叫克隆模式。克隆模式分为两种，一种是浅度克隆，一种是深度克隆，至于这两者之前的区别，看下面的代码。浅度克隆实体类，没有特别的作用，作为原型对象(其实就是克隆对象，原型是一个别名)中的一个引用类型的属性packagecom.gxl.demo.DesignPattern.cl...
Java设计模式-原型模式详解
11-24
Java 设计模式 - 原型模式详解 原型模式是 Java 设计模式之一，它用于创建对象时，指定创建对象的类型，并通过拷贝这些原型创建新的对象。该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原...
最简单的深拷贝
飘云羽逸
10-16 236
package com.leitan.architect.pattern.prototype.deep;import java.io.*;import java.util.Date;public class QiTianDaSheng extends Monkey implements Cloneable, Serializable { public JinG...
设计模式-原型模式
01-02 129
Java原型模式(prototype) 写文章 Java原型模式(prototype) prototype模式也就是原型模式，是创建型模式的一种，在学习spring时，在bean标签的学习中碰到过，所以本文来给大家介绍下原型模式 原型模式   在java中我们知道通过new关键字创建的对象是非常繁琐的(类加载判断，内存分配，初...
Java设计模式——创建型模式：原型模式（克隆模式）
qq_35531985的博客
10-18 117
模式定义 原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。 模式介绍 动机：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 优点：1、性能提高。 2、逃避构造函数的约束。 缺点： 1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别
java怎么复制一个构造方法_java – clone()vs复制构造函数vs工厂方法？
weixin_32098191的博客
02-24 215
我做了一个快速google上实现clone()在Java中，发现：http://www.javapractices.com/topic/TopicAction.do?Id=71它有以下评论：copy constructors and static factory methods provide an alternative to clone, and are much easier to impl...
克隆模式java_Java 设计模式 之 克隆模式
weixin_36205072的博客
02-28 81
浅克隆package com.clone.theory;public class TestClone{public static void main(String[] args){Prototype p=new Prototype("李阳");System.out.println(p.getName());Prototype p2=(Prototype)p.clone();System.out.p...
ava常用设计模式-原型模式
最新发布
08-26
ava常用设计模式-原型模式 原型模式（Prototype Pattern）是一种创建型设计模式，允许通过复制现有对象来创建新对象，而不是通过实例化类来创建新对象。在需要创建大量相似对象时非常有用，它可以避免重复创建对象...
24设计模式-原型模式1
08-04
原型模式是一种设计模式，主要目的是通过复制现有对象来创建新对象，从而简化创建过程并减少对象构造的开销。在Java中，实现原型模式通常涉及`Cloneable`接口和`clone()`方法。`Cloneable`接口是一个标记接口，类...
java设计模式【之】原型模式、深拷贝与浅拷贝【源码】【场景：克隆羊】
03-31
java设计模式【之】原型模式、深拷贝与浅拷贝【源码】【场景：克隆羊】 * 原型模式(Prototype) * 实现方式： * 需要被克隆的 class类， 重写Object中的clone()方法，并实现Cloneable接口（否则报错 ...
详解Java的设计模式编程中的原型模式
09-02
Java的设计模式之一是原型模式，它是创建类模式的一种，用于创建和复制对象。原型模式的主要目的是通过拷贝现有的对象来创建新的对象，从而避免了传统构造函数创建新对象的复杂性和资源消耗。在Java中，原型模式的...
Java 设计模式：创造者模式（单例、原型、工厂、建造者）
AcWare 学习笔记
12-13 378
创造者模式包括 单例模式、原型模式、工厂方法模式、抽象工厂模式、建造者模式
拷贝构造函数和拷贝工厂
04-07 672
除了clone以外，另一个实现对象拷贝的好办法四提供一个拷贝构造器或拷贝工厂! 转载于:https://my.oschina.net/u/2479387/blog/874521...
java 克隆对象_原型模式，克隆就在我们身边
weixin_42514394的博客
12-03 58
作者 | Java圣斗士 | 原创图文 ，转载请注明出处全文1000字，阅读需要5分钟哈喽，大家好，我是又皮又可爱的Java圣斗士，关注我，每天带你飞！今天我们来聊一聊原型模式。原型模式应该算是比较简单的一种设计模式，其实一个词就可以概括，那就是——克隆对象！我们经常在各种影视作品中看到“克隆”这个科技元素，是不是十分带感呢？我记得小时候最令我震撼的克隆电影就是州长的《第六日》，里面讲述了一个.....
Java面向对象设计模式学习（二）：创建型模式（单例、原型、工厂、抽象工厂）
Jiang216的博客
08-04 199
本文主要包括Java设计模式中的创建型模式分类下的部分设计模式： 一、单例模式(Singleton) 单例模式是指一个类只能有一个实例，且该类能自行创建这个实例的设计模式。 通常情况下，普通类的构造函数是公有的，外部类可以通过“new 构造函数()”来生成多个实例。但是，如果将类的构造函数设为私有的，外部类就无法调用该构造函数，也就无法生成多个实例。这时该类自身必须定义一个静态私有实例，并向外提供一个静态的公有函数用于创建或获取该静态私有实例。 单例模式结构图如下： 单例模式又可以细分为懒汉.
Java---工厂方法（简单工厂）
天才周的博客
07-16 167
所谓的工厂方法其实最主要的特点就是多态和抽象下面上代码吧：public interface IPlant { }public class Flower implements IPlant { public Flower(){ System.out.println("生产出一朵花"）;public class Grass implements IPlant { p...
面向对象进阶
阳神
02-08 283
继承 继承是面向对象程序设计的重要特征，也是实现“代码复用”的重要手段。 如果一个新类继承自一个设计好的类，就直接具备了已有类的特征，就大大降低了工作 难度。已有的类，我们称为“父类或者基类”，新的类，我们称为“子类或者派生类”。 语法格式 Python 支持多重继承，一个子类可以继承多个父类。继承的语法格式如下： class 子类类名(父类 1[，父类 2，...])： 类体 如果在...
研磨设计模式之工厂方法模式-2
跟着cc学设计 私塾在线学习网 http://sishuok.com
06-17 109
     2  解决方案 2.1  工厂方法模式来解决         用来解决上述问题的一个合理的解决方案就是工厂方法模式。那么什么是工厂方法模式呢？（1）工厂方法模式定义        定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到其子类。   （2）应用工厂方法模式来解决的思路        仔细分析上面的问题，事实上在实...
工厂模式——简单工厂模式 && 智能指针的使用
IT8343的博客
02-24 724
概述： 定义：定义一个工厂类，他可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类 在简单工厂模式中用于被创建实例的方法通常为静态(static)方法,因此简单工厂模式又被成为静态工厂方法(Static Factory Method) 需要什么，只需要传入一个正确的参数，就可以获取所需要的对象，而无需知道其实现过程 结构： 1.工厂类(factory)：核心部分，负责实现创建所有产品的内部逻辑，工厂类可以被外界直接调用，创建所需对象。 2.抽象产品类：工厂

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员黄小青

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值