Java设计模式--原型模式

楠方嘉木

已于 2023-02-06 10:21:37 修改

阅读量637

点赞数

文章标签：原型模式 java 设计模式 Powered by 金山文档

于 2023-02-03 18:01:43 首次发布

本文链接：https://blog.csdn.net/qq_36900609/article/details/128873352

版权

概念：用原型实例（最初的）指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。（自我复制能力）

1.类图

原理类图分析

Prototype：原型类，声明一个克隆自己的接口

ConcretePrototype：具体的原型类，实现一个克隆自己的操作

Client：让一个原型对象克隆自己，从而创建一个属性一样的新的对象

2.代码示例

sheep实体类

package org.example.prototype;

import lombok.Data;

//通过实现Cloneable接口，重写clone()方法，拥有克隆的能力
@Data
public class Sheep implements Cloneable{

    String name;
    int age;
    String color;

    public Sheep(){}

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

    // 克隆该实例，使用默认的克隆方法来完成
    @Override
    protected Object clone(){
        Sheep sheep = null;
        try {
            sheep = (Sheep)super.clone();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return sheep;
    }
}

客户端

使用克隆功能并验证

package org.example.prototype;

public class Client {
    public static void main(String[] args) {
        System.out.println("原型模式，完成对象的创建 ");
        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();

        System.out.println(sheep == sheep1);

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

结果输出

原型模式，完成对象的创建 
false
sheep = Sheep(name=tom, age=1, color=白色)
sheep1 = Sheep(name=tom, age=1, color=白色)
sheep2 = Sheep(name=tom, age=1, color=白色)
sheep3 = Sheep(name=tom, age=1, color=白色)
sheep4 = Sheep(name=tom, age=1, color=白色)

Process finished with exit code 0

3.深入讨论--深拷贝、浅拷贝

3.1 浅拷贝

对于基本数据类型进行值传递，将属性值复制一份给新的对象

对于引用数据类型，比如成员变量是某个数组或某个类的对象，那么会进行引用传递，就是将该成员变量的引用值（内存地址）复制一份给新的对象。因此实际上两个对象的该成员变量都指向同一个实例

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

3.2 深拷贝

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

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

实现方式：

重写clone方法实现；

通过对象序列化实现；

package org.example.prototype;

import lombok.Data;

import java.io.*;

@Data
public class DeepProtoType implements Serializable,Cloneable {
    private String name;

    private DeepCloneableTarget deepCloneableTarget;

    public DeepProtoType(){
        super();
    }

    // 深拷贝方式1--重写clone实现深拷贝
    @Override
    protected Object clone() throws CloneNotSupportedException {
        DeepProtoType deepProtoType = null;
        deepProtoType = (DeepProtoType)super.clone();
        deepProtoType.deepCloneableTarget = (DeepCloneableTarget)deepCloneableTarget.clone();
        return deepProtoType;
    }

    // 深拷贝方式2--通过序列化和反序列话实现（推荐使用）
    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 (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}