学习笔记【23种设计模式-第四节：Prototype原型模式 -克隆羊、深浅拷贝】

于 2020-12-15 18:11:57 发布
阅读量118 收藏
点赞数
分类专栏： # 23种设计模式 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53273362/article/details/111224585
版权

Prototype原型模式

简述：

  • 原型模式（Prototype模式）是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。
  • 原型模式是一种创建型设计模式，允许一个对象再创建另一个可定制的对象，无需知道如何创建的细节。
  • 工作原理是：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即对象.clone()
  • 形象的理解：孙悟空拔出猴毛，变出其他孙猴子。

例子：克隆羊：

Sheep类实现了Cloneable接口，重写了clone方法：

public class Sheep implements Cloneable{
    private String name;
    private int age;
    private String color;

    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 + '\'' +
                '}';
    }
//使用默认的克隆方法
    @Override
    protected Object clone()  {
        Sheep sheep=null;
        try{
            sheep= (Sheep) super.clone();
        }catch (Exception e){
            e.printStackTrace();
        }
        return sheep;
    }
}

主方法：

public class Client {
    public static void main(String[] args) {
        Sheep sheep=new Sheep("Tom",1,"白色");
        Sheep sheep1= (Sheep) sheep.clone();
        Sheep sheep2= (Sheep) sheep.clone();
        Sheep sheep3= (Sheep) sheep.clone();
        Sheep sheep4= (Sheep) sheep.clone();
        Sheep sheep5= (Sheep) sheep.clone();

        System.out.println("sheep1="+sheep1);
        System.out.println("sheep2="+sheep2);
        System.out.println("sheep3="+sheep3);
        System.out.println("sheep4="+sheep4);
        System.out.println("sheep5="+sheep5);

    }
}

比传统一个一个创建更具有效率及扩展性。

Spring中的 bean创建就用到了原型模式，因为还没学到Spring，所以先放放，到时回头来看。

浅拷贝

拿前面克隆羊的例子，若在属性中多加个羊的朋友属性：

 private String name;
    private int age;
    private String color;
    public Sheep friend;

再在主方法上给原羊一个朋友Jack、2岁、黑色，看看克隆出来的羊的朋友是否为同一对象：

public class Client {
    public static void main(String[] args) {
        Sheep sheep=new Sheep("Tom",1,"白色");
        sheep.friend=new Sheep("jack",2,"黑色");
        Sheep sheep1= (Sheep) sheep.clone();
        Sheep sheep2= (Sheep) sheep.clone();
        System.out.println("原羊="+sheep+";原羊 friend="+sheep.friend.hashCode());
        System.out.println("sheep1="+sheep1+";sheep1 friend="+sheep1.friend.hashCode());
        System.out.println("sheep2="+sheep2+";sheep2 friend="+sheep2.friend.hashCode());
    }
}

结果：
在这里插入图片描述
结论是克隆出来的羊并没有重新创建朋友对象，而是指向了原羊的朋友对象。

浅拷贝简述：
  • 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性复制一份给新的对象。
  • 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将成员变量的引用值（内存地址）复制了一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响对另一个对象的该成员变量值。
  • 前面我们克隆羊就是浅拷贝。
  • 浅拷贝是使用默认的clone()方法来实现的（sheep=(Sheep) super.clone();）

深拷贝

简述：

  • 复制对象的基本数据类型的成员变量值。
  • 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝。
  • 深拷贝实现方式1：重写clone方法来实现
  • 深拷贝实现方式2：通过对象序列化来实现
方式一：重写clone方法实现

两个类DeepCloneableTarget与DeepPrototype，都需要实现Cloneable接口，DeepCloneableTarget有两个String属性，DeepPrototype有一个DeepCloneableTarget属性及一个String属性。

类DeepCloneableTarget：

public class DeepCloneableTarget implements Serializable,Cloneable {
    private static final long serialVersionUID=1L;
    private String cloneName;
    private String cloneClass;

    public DeepCloneableTarget(String cloneName, String cloneClass) {
        this.cloneName = cloneName;
        this.cloneClass = cloneClass;
    }

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

类DeepPrototype：

public class DeepPrototype implements Serializable,Cloneable {
    public String name;
    public DeepCloneableTarget deepCloneableTarget;

    public DeepPrototype() {
    }
    //方式一：使用clone方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object deep=null;
        deep=super.clone();
        //对引用数据类型的属性，进行单独处理
        DeepPrototype deepPrototype=(DeepPrototype)deep;
        deepPrototype.deepCloneableTarget=(DeepCloneableTarget) deepCloneableTarget.clone();
        return deepPrototype;
    }
}

主方法：

public class Client {
    public static void main(String[] args) {
        DeepPrototype p=new DeepPrototype();
        p.name="洋洋";
        p.deepCloneableTarget=new DeepCloneableTarget("大牛","大牛.class");
        DeepPrototype p1 = null;
        try {
           p1= (DeepPrototype) p.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        System.out.println("p.name="+p.name+";P.deepCloneableTarget="+p.deepCloneableTarget.hashCode());
        System.out.println("p1.name="+p1.name+";P1.deepCloneableTarget="+p1.deepCloneableTarget.hashCode());
    }
}

结果：
在这里插入图片描述

可发现这样指向的就不是同一个内存地址了。但是如果有多个引用类型的属性，得一个一个单独处理。

方式二：通过反序列化（推荐）

重复的就不写了，直接写DeepPrototype的克隆方法：

//方式二：通过序列化的方式(推荐使用)
    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);
            DeepPrototype deepPrototype= (DeepPrototype) ois.readObject();
            return deepPrototype;
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }finally {
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

主方法：

public class Client {
    public static void main(String[] args) {
        DeepPrototype p=new DeepPrototype();
        p.name="洋洋";
        p.deepCloneableTarget=new DeepCloneableTarget("大牛","大牛.class");
     
        DeepPrototype p2= (DeepPrototype) p.deepClone();
        System.out.println("p.name="+p.name+";P.deepCloneableTarget="+p.deepCloneableTarget.hashCode());
        System.out.println("p2.name="+p2.name+";P2.deepCloneableTarget="+p2.deepCloneableTarget.hashCode());
    }
}

结果：
在这里插入图片描述
优点：多个引用类型也是一次即可。

深拷贝注意事项：

  • 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时可能够提高效率。
  • 不用对重新初始化对象，而是动态的获得对象运行时的状态。
  • 如果原始对象发生变化（增加或者减少属性），其他克隆对象的也会发生相应的变化，无需修改代码。
  • 在实现深克隆时可能需要比较复杂的代码。
  • 缺点： 需要为每个类配备一个克隆方法，这对全新的类来说没什么，但对已有的类进行改造时，需要修改其源代码，违背了ocp原则。
十月花
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值