设计模式（四）原型模式

文章目录

原型模式简介
结构
UML图
具体实现
关于拷贝
- 浅拷贝
- 深拷贝
- 实现深拷贝方法

原型模式简介

原型模式是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。
工作原理：原型模式创建新的对象，其本质就是克隆，也就是对象.clone()。

结构

Prototype：原型类，申明一个克隆自己的接口，Java语言中顶级类Object默认有clone()；
ConcretePrototype：具体的原型类，实现一个克隆自己的操作。
Client：让一个原型对象克隆自己，从而创建一个新的对象。

UML图

在这里插入图片描述

具体实现

UML图
绵羊类（原型类）

package com.xxliao.pattern.creational.prototype.demo;

/**
 * @author xxliao
 * @description: 绵羊类，实现Cloneable接口
 * @date 2024/5/24 13:22
 */
public class Sheep implements Cloneable{

    private String name;
    private int age;
    private String color;
    private String address;
    public Sheep friend; // 对象

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

    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;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

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

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

测试客户端

package com.xxliao.pattern.creational.prototype.demo;

/**
 * @author xxliao
 * @description: 设计模式 - 原型模式 -测试客户端
 * @date 2024/5/24 13:27
 */
public class Client {

    public static void main(String[] args) throws CloneNotSupportedException {
        Sheep sheep = new Sheep("tom",1,"白色","内蒙");
        sheep.friend = new Sheep("timi",2,"黑色","宁夏");

        Sheep sheep1 = (Sheep) sheep.clone();
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();
        Sheep sheep4 = (Sheep) sheep.clone();

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

关于拷贝

浅拷贝

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

深拷贝

复制对象的所有基础数据类型的成员变量值，为所有引用数据类型的成员变量申请存储空间，并复制每一个引用数据类型变量所引用的对象。

实现深拷贝方法

实现深拷贝有两个方法：重写clone方法和利用对象的序列化。

深拷贝实现

package com.xxliao.pattern.creational.prototype.deep_clone_demo;

import java.io.*;

/**
 * @author xxliao
 * @description: 深拷贝实现-重写clone方法
 * @date 2024/5/24 13:41
 */

public class DeepCloneable implements Cloneable,Serializable{

    private String name;

    private DeepCloneable friend;

    public String getName() {
        return name;
    }

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

    public DeepCloneable getFriend() {
        return friend;
    }

    public void setFriend(DeepCloneable friend) {
        this.friend = friend;
    }

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

    /**
     * @description  重写clone方法 实现深拷贝
     * @author  xxliao
     * @date  2024/5/24 13:50
     */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object deep = null;
        deep = super.clone();
        DeepCloneable deepCloneable = (DeepCloneable) deep;
        System.out.println(this);
        deepCloneable.friend = friend != null ? (DeepCloneable) friend.clone() : null;
        return deepCloneable;
    }

    /**
     * @description  利用对象的序列化实现深拷贝
     * @author  xxliao
     * @date  2024/5/24 13:50
     */

    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);
            return ois.readObject();
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }finally {

            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

测试客户端

package com.xxliao.pattern.creational.prototype.deep_clone_demo;

/**
 * @author xxliao
 * @description: 深拷贝测试客户端
 * @date 2024/5/24 13:57
 */

public class Client {

    public static void main(String[] args) throws CloneNotSupportedException {
        DeepCloneable one = new DeepCloneable();
        one.setName("one");
        DeepCloneable two = new DeepCloneable();
        two.setName("two");
        one.setFriend(two);

        System.out.println(one);
        // 完成深拷贝 - 重写clone
        DeepCloneable clone = (DeepCloneable) one.clone();
        System.out.println(clone);

        // 完成深拷贝 - 序列化
        DeepCloneable deepCloneable = (DeepCloneable) one.deepClone();
        System.out.println(deepCloneable);
    }
}