原型模式：clone 的陷阱、深拷贝的三种做法与选型指南

public class Object {
    protected native Object clone() throws CloneNotSupportedException;
}

import java.util.ArrayList;
import java.util.List;

/** 浅拷贝：Object.clone() 的默认行为 */
public class ShallowCopyDemo {

    static class Order implements Cloneable {
        String id;
        List<String> items = new ArrayList<>();

        Order(String id, String... items) {
            this.id = id;
            for (String s : items) this.items.add(s);
        }

        @Override
        public Order clone() {
            try {
                return (Order) super.clone();     // 逐字段位复制
            } catch (CloneNotSupportedException e) {
                throw new AssertionError(e);      // 实现了 Cloneable，走不到这里
            }
        }
    }

    public static void main(String[] args) {
        Order origin = new Order("A-1", "键盘", "鼠标");
        Order copy = origin.clone();

        System.out.println(origin != copy);                       // true：确实是两个对象
        System.out.println(origin.getClass() == copy.getClass()); // true：类型也一致
        System.out.println(origin.items == copy.items);           // true：⚠️ 同一个 List 实例

        copy.items.add("显示器");
        System.out.println(origin.items);                         // [键盘, 鼠标, 显示器] ← 原件被污染
    }
}

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

public class ManualDeepCloneDemo {

    static class Order implements Cloneable, Serializable {
        private static final long serialVersionUID = 1L;

        String id;
        List<String> items;
        int[] quantity;

        Order(String id, List<String> items, int[] quantity) {
            this.id = id;
            this.items = items;
            this.quantity = quantity;
        }

        @Override
        public Order clone() {
            try {
                Order copy = (Order) super.clone();                 // 1) 先浅拷贝
                copy.items = new ArrayList<>(this.items);           // 2) 集合：新建一份
                copy.quantity = this.quantity.clone();              // 3) 数组：数组的 clone 是浅拷贝但够用
                return copy;                                        // 4) 若有嵌套对象，要递归拷贝
            } catch (CloneNotSupportedException e) {
                throw new AssertionError(e);
            }
        }
    }

    public static void main(String[] args) {
        Order origin = new Order("A-1", new ArrayList<>(List.of("键盘")), new int[]{1});
        Order copy = origin.clone();

        copy.items.add("显示器");
        copy.quantity[0] = 99;

        System.out.println(origin.items);      // [键盘] ← 不再被污染
        System.out.println(origin.quantity[0]); // 1
    }
}

import java.io.*;

public final class DeepCopy {
    private DeepCopy() {}

    @SuppressWarnings("unchecked")
    public static <T extends Serializable> T of(T obj) {
        try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
             ObjectOutputStream oos = new ObjectOutputStream(bos)) {
            oos.writeObject(obj);
            try (ObjectInputStream ois =
                         new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()))) {
                return (T) ois.readObject();
            }
        } catch (IOException | ClassNotFoundException e) {
            throw new IllegalStateException("深拷贝失败", e);
        }
    }
}

import java.util.ArrayList;
import java.util.List;

public class CopyConstructorDemo {

    static final class Report {
        private final String title;
        private final List<String> rows;      // final 字段也能正常拷贝

        Report(String title, List<String> rows) {
            this.title = title;
            this.rows = new ArrayList<>(rows);   // 构造时做防御性拷贝
        }

        /** 拷贝构造器：语义显式，不需要 Cloneable，不抛受检异常 */
        Report(Report other) {
            this(other.title, other.rows);
        }

        /** 拷贝工厂：静态方法版本，可以配合泛型做类型转换 */
        static Report copyOf(Report other) {
            return new Report(other);
        }

        Report withExtraRow(String row) {      // 不可变风格的"改一点"：返回新对象
            List<String> next = new ArrayList<>(rows);
            next.add(row);
            return new Report(title, next);
        }

        List<String> rows() {
            return new ArrayList<>(rows);      // 出口也拷贝，防止外部改内部状态
        }
    }

    public static void main(String[] args) {
        Report origin = new Report("月度报表", new ArrayList<>(List.of("华东")));
        Report copy = Report.copyOf(origin).withExtraRow("华南");

        System.out.println(origin.rows());  // [华东]      ← 原件不受影响
        System.out.println(copy.rows());    // [华东, 华南]
    }
}

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class PrototypeRegistryDemo {

    interface Shape extends Cloneable {
        Shape copy();          // 现代写法：自定义 copy()，避免暴露 Cloneable/clone()
        void draw();
        void scale(int factor);
    }

    static class Circle implements Shape {
        private int radius;
        private String color;

        Circle(int radius, String color) { this.radius = radius; this.color = color; }

        @Override public Shape copy() { return new Circle(radius, color); }
        @Override public void scale(int factor) { radius *= factor; }
        @Override public void draw() { System.out.println("圆形 r=" + radius + " color=" + color); }
    }

    static class Square implements Shape {
        private int side;
        private String color;

        Square(int side, String color) { this.side = side; this.color = color; }

        @Override public Shape copy() { return new Square(side, color); }
        @Override public void scale(int factor) { side *= factor; }
        @Override public void draw() { System.out.println("方形 a=" + side + " color=" + color); }
    }

    /** 原型管理器：保存"样本"，create() 永远返回副本 */
    static class ShapeRegistry {
        private final Map<String, Shape> prototypes = new HashMap<>();

        void register(String key, Shape prototype) {
            prototypes.put(key, prototype);
        }

        Shape create(String key) {
            Shape prototype = prototypes.get(key);
            if (prototype == null) {
                throw new IllegalArgumentException("未注册的原型: " + key);
            }
            return prototype.copy();              // 关键：交出去的是副本，不是样本本身
        }
    }

    public static void main(String[] args) {
        ShapeRegistry registry = new ShapeRegistry();
        registry.register("small-circle", new Circle(10, "red"));
        registry.register("small-square", new Square(5, "blue"));

        Shape a = registry.create("small-circle");
        a.scale(3);                                // 只影响副本
        a.draw();                                  // 圆形 r=30 color=red

        registry.create("small-circle").draw();     // 圆形 r=10 color=red ← 样本没被改动
    }
}