Java23种设计模式-创建型模式之原型模式

原型模式(Prototype Pattern)是一种创建型设计模式，它允许通过复制现有对象来生成新对象，而无需编写从头开始创建新对象的代码。

优点：可以克隆对象，无需与它们所属的具体类相耦合；可以克隆预生成原型，避免反复运行初始化代码；提高性能等。
缺点：克隆包含循环引用的复杂对象可能会非常麻烦；配备克隆方法需要对类的功能进行通盘考虑；必须实现Cloneable接口等
实现方式：
浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。
深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

使用场景：
1.类初始化需要消化非常多的资源，包括数据、硬件资源。
2.通过new产生一个对象需要非常繁琐的数据准备或访问权限。
3.一个对象多个修改者的场景。

工作原理是：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即“对象.clone( )”。
示例：设置一个原型类MyObject 然后创建深拷贝类MyObjectDeepClone 和浅拷贝类MyObjectShallowClone 最后创建一个测试类Client 然后修改数据 打印查看即可知浅拷贝和深拷贝区别。

//原型类
class MyObject {
    private int basicField;
    private List<String> objectField;

    public int getBasicField() {
        return basicField;
    }

    public void setBasicField(int basicField) {
        this.basicField = basicField;
    }

    public List<String> getObjectField() {
        return objectField;
    }

    public void setObjectField(List<String> objectField) {
        this.objectField = objectField;
    }

    public MyObject(int basicField, List<String> objectField) {
        this.basicField = basicField;
        this.objectField = new ArrayList<>(objectField);
    }
    @Override
    public String toString() {
        return "MyObject{" +
                "basicField=" + basicField +
                ", objectField=" + objectField +
                '}';
    }
}

//深拷贝
class MyObjectDeepClone {
    private MyObject innerObject;

    public MyObjectDeepClone(MyObject innerObject) {
        this.innerObject = new MyObject(innerObject.getBasicField(), new ArrayList<>(innerObject.getObjectField()));
    }

    public MyObjectDeepClone deepClone() {
        return new MyObjectDeepClone(new MyObject(innerObject.getBasicField(), new ArrayList<>(innerObject.getObjectField())));
    }

    @Override
    public String toString() {
        return "MyObjectDeepClone{" +
                "innerObject=" + innerObject +
                '}';
    }
}
//浅拷贝
class MyObjectShallowClone implements Cloneable {
    private MyObject innerObject;

    public MyObjectShallowClone(MyObject innerObject) {
        this.innerObject = innerObject;
    }

    public MyObjectShallowClone clone() {
        try {
            return (MyObjectShallowClone) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new Error("This shouldn't happen", e);
        }
    }

    @Override
    public String toString() {
        return "MyObjectShallowClone{" +
                "innerObject=" + innerObject +
                '}';
    }
}
//验证测试
public class Client {
    public static void main(String[] args) throws Exception {
        List<String> objectField =new ArrayList<>();
        objectField.add("aaaa");
         //原始类
        MyObject myObject=new MyObject(1,objectField);
		//深拷贝
        MyObjectDeepClone myObjectDeepClone = new MyObjectDeepClone(myObject);
        //浅拷贝
        MyObjectShallowClone myObjectShallowClone=new MyObjectShallowClone(myObject);
        //深拷贝打印
		System.out.println(myObjectDeepClone);
		//MyObjectDeepClone{innerObject=MyObject{basicField=1, objectField=[aaaa]}}
		//浅拷贝
        System.out.println(myObjectShallowClone);
		//MyObjectShallowClone{innerObject=MyObject{basicField=1, objectField=[aaaa]}}
		//修改原始数据
        objectField.add("ssss");
        myObject.setObjectField(objectField);
        
       	//打印判断是否变化，输出发生变化的为浅拷贝
        System.out.println(myObjectShallowClone);
        //MyObjectShallowClone{innerObject=MyObject{basicField=1, objectField=[aaaa, ssss]}}
        System.out.println(myObjectDeepClone);
        //MyObjectDeepClone{innerObject=MyObject{basicField=1, objectField=[aaaa]}}

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105