Prototype 模式

/**
 * 原型接口
 */
interface Prototype {
    Prototype clone();
}

/**
 * 具体原型：文档
 */
class Document implements Prototype {
    private String title;
    private String content;
    private String author;

    public Document(String title, String content, String author) {
        this.title = title;
        this.content = content;
        this.author = author;
    }

    // 实现克隆方法
    @Override
    public Document clone() {
        return new Document(this.title, this.content, this.author);
    }

    // Getters and Setters
    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }
    public String getContent() { return content; }
    public void setContent(String content) { this.content = content; }
    public String getAuthor() { return author; }
    public void setAuthor(String author) { this.author = author; }

    @Override
    public String toString() {
        return "Document{title='" + title + "', content='" + content + "', author='" + author + "'}";
    }
}

// 使用
public class PrototypeDemo {
    public static void main(String[] args) {
        // 创建原型文档
        Document prototype = new Document("项目报告", "这是项目报告的内容", "张三");
        System.out.println("原型: " + prototype);

        // 克隆文档
        Document copy1 = prototype.clone();
        copy1.setTitle("项目报告 - 副本1");
        copy1.setContent("这是副本1的修改内容");

        Document copy2 = prototype.clone();
        copy2.setTitle("项目报告 - 副本2");

        System.out.println("副本1: " + copy1);
        System.out.println("副本2: " + copy2);
    }
}

/**
 * 实现 Cloneable 接口的原型
 */
class ShallowCopyExample implements Cloneable {
    private String name;
    private int[] data;

    public ShallowCopyExample(String name, int[] data) {
        this.name = name;
        this.data = data;
    }

    @Override
    protected ShallowCopyExample clone() {
        try {
            // Object 的 clone() 方法是浅拷贝
            return (ShallowCopyExample) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }

    // Getters and Setters
    public String getName() { return name; }
    public int[] getData() { return data; }
    public void setData(int index, int value) { data[index] = value; }

    @Override
    public String toString() {
        return name + ": " + java.util.Arrays.toString(data);
    }
}

// 演示浅拷贝问题
public class ShallowCopyDemo {
    public static void main(String[] args) {
        int[] dataArray = {1, 2, 3, 4, 5};
        ShallowCopyExample original = new ShallowCopyExample("Original", dataArray);

        // 克隆对象
        ShallowCopyExample cloned = original.clone();
        cloned.setName("Cloned");

        // 修改克隆对象的数组
        cloned.setData(0, 999);

        System.out.println("Original: " + original);  // Original: [999, 2, 3, 4, 5]
        System.out.println("Cloned: " + cloned);      // Cloned: [999, 2, 3, 4, 5]

        // 问题：原对象的数组也被修改了！
    }
}

/**
 * 深拷贝实现示例
 */
class DeepCopyExample implements Cloneable {
    private String name;
    private int[] data;

    public DeepCopyExample(String name, int[] data) {
        this.name = name;
        // 复制数组，确保独立
        this.data = data.clone();
    }

    @Override
    protected DeepCopyExample clone() {
        try {
            DeepCopyExample cloned = (DeepCopyExample) super.clone();
            // 深拷贝：也要复制数组
            cloned.data = this.data.clone();
            return cloned;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }

    // Getters and Setters
    public String getName() { return name; }
    public int[] getData() { return data; }
    public void setData(int index, int value) { data[index] = value; }

    @Override
    public String toString() {
        return name + ": " + java.util.Arrays.toString(data);
    }
}

// 演示深拷贝
public class DeepCopyDemo {
    public static void main(String[] args) {
        int[] dataArray = {1, 2, 3, 4, 5};
        DeepCopyExample original = new DeepCopyExample("Original", dataArray);

        // 克隆对象
        DeepCopyExample cloned = original.clone();
        cloned.setName("Cloned");
        cloned.setData(0, 999);

        System.out.println("Original: " + original);  // Original: [1, 2, 3, 4, 5]
        System.out.println("Cloned: " + cloned);      // Cloned: [999, 2, 3, 4, 5]

        // 现在：原对象的数组没有被修改，完全独立！
    }
}

import java.io.*;

/**
 * 使用序列化实现深拷贝
 * 适用于复杂对象的深拷贝
 */
class SerializationUtil {
    @SuppressWarnings("unchecked")
    public static <T extends Serializable> T deepCopy(T obj) {
        try {
            // 序列化到字节数组
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(obj);
            oos.flush();

            // 从字节数组反序列化
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (T) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException("Deep copy failed", e);
        }
    }
}

/**
 * 可序列化的复杂对象
 */
class ComplexObject implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private nestedObject nested;

    public ComplexObject(String name, String nestedValue) {
        this.name = name;
        this.nested = new nestedObject(nestedValue);
    }

    private static class nestedObject implements Serializable {
        private static final long serialVersionUID = 1L;
        private String value;
        public nestedObject(String value) { this.value = value; }
        public String getValue() { return value; }
        public void setValue(String value) { this.value = value; }
    }

    // Getters
    public String getName() { return name; }
    public nestedObject getNested() { return nested; }
}

// 使用序列化进行深拷贝
public class SerializationCopyDemo {
    public static void main(String[] args) {
        ComplexObject original = new ComplexObject("Original", "Nested Value");

        // 使用序列化进行深拷贝
        ComplexObject cloned = SerializationUtil.deepCopy(original);

        // 修改克隆对象
        cloned.getNested().setValue("Modified");

        System.out.println("Original nested: " + original.getNested().getValue());
        System.out.println("Cloned nested: " + cloned.getNested().getValue());

        // Original 和 Cloned 完全独立
    }
}