原型模式（Prototype）：-CSDN博客

本文链接：https://blog.csdn.net/xyy1609914390/article/details/147685001

定义：用原型的实例指定创建对象的种类，并且通过复制这些原型创建新的对象

public class Test {

    public static void main(String[] args){
        
        ConcretePrototype p1 = new ConcretePrototype("编号123456");
        System.out.println("原ID:"+ p1.getID());

        ConcretePrototype c1 = (ConcretePrototype)p1.clone();
        System.out.println("克隆ID:"+ c1.getID());
    }
}

//原型类
abstract class Prototype implements Cloneable {
    private String id;

    public Prototype(String id){
        this.id=id;
    }

    public String getID(){
        return this.id;
    }

    //原型模式的关键就是有这样一个clone方法
    public Object clone(){
        Object object = null;
        try {
            object = super.clone();
        }
        catch(CloneNotSupportedException exception){
            System.err.println("Clone异常。");
        }
        return object;
    }
}

//具体原型类
class ConcretePrototype extends Prototype{

    public ConcretePrototype(String id){
        super(id);
    }

}

这里分为浅复制和深复制：

浅复制，也就是浅表复制，对于传值（如String)没问题，但是对于传引用（如对象，数组等）来说，新对象的该属性会和原对象的属性指向同一个应用。也就是说，传引用的话，修改后一个克隆对象的属性会同时修改被克隆对象的属性。传引用需要用到深复制

class InnerClass {
    private int innerValue;
    public InnerClass(int innerValue) {
        this.innerValue = innerValue;
    }
    public int getInnerValue() {
        return innerValue;
    }
}
class OuterClass implements Cloneable {

    private InnerClass inner;

    public OuterClass(InnerClass inner) {
        this.inner = inner;
    }

    @Override
    public OuterClass clone() {
        // 声明一个 OuterClass 类型的变量，用于存储克隆后的对象
        OuterClass object = null;

        try {
            // 调用父类的 clone() 方法，克隆出一个 OuterClass 类型的对象
            object = (OuterClass) super.clone();
            // 克隆出一个 InnerClass 类型的对象，并将其赋值给克隆后的 OuterClass 对象的 inner 属性
            object.inner = new InnerClass(this.inner.getInnerValue()); // 注意：这里使用的是 this.inner.getInnerValue() 而不是 inner.getInnerValue()

        }
        catch (CloneNotSupportedException e) {
            System.out.println("clone 异常");  // 如果克隆不被支持，则抛出错误
        }
        return object;  返回克隆后的对象
    }
}