Five prototype patterns for Java Design patterns (Prototype)

Although the prototype pattern is a pattern of creation, it has nothing to do with the engineering model, and the idea of the pattern is to copy and clone an object as a prototype, and create a new object similar to the original object. This summary will be explained by the copy of the object. In Java, the Copy object is implemented through clone (), and a prototype class is created first:

[Java]View Plaincopy

1. public class Prototype implements cloneable {
3. Public Object Clone () throws Clonenotsupportedexception {
4. Prototype proto = (Prototype) super.clone ();
5. return proto;
6. }
7. }

Very simple, a prototype class, only need to implement the Cloneable interface, overwrite the Clone method, where the Clone method can be changed to any name, because the Cloneable interface is an empty interface, you can arbitrarily define the method name of the implementation class, such as Clonea or CLONEB, Because the focus here is Super.clone (), Super.clone () invokes the Clone () method of object, whereas in the object class, Clone () is native, and I'll do it in another article, The call to interpret native methods in Java is no longer a drill down here. Here, I'll take a look at the shallow copy and deep copy of the object, and first we need to understand the concept of deep, shallow copying of objects:

Shallow copy: After copying an object, the variables of the base data type are recreated, and the reference type, pointing to the original object.

Deep copy: After copying an object, both the base data type and the reference type are recreated. In short, deep replication is completely replicated, and shallow copying is not exhaustive.

Here, write an example of a depth copy:

[Java]View Plaincopy

2. public class Prototype implements Cloneable, Serializable {
6. Private static final long serialversionuid = 1L;
8. private string string;
12. Private Serializableobject obj;
16. /* Shallow copy */
18. Public Object Clone () throws Clonenotsupportedexception {
20. Prototype proto = (Prototype) super.clone ();
22. return proto;
24. }
28. /* Deep copy */
30. Public Object Deepclone () throws IOException, ClassNotFoundException {
34. /* writes the binary stream of the current object */
36. Bytearrayoutputstream BOS = new Bytearrayoutputstream ();
38. ObjectOutputStream oos = new ObjectOutputStream (BOS);
40. Oos.writeobject (this);
44. /* read out the new object generated by the binary stream */
46. Bytearrayinputstream bis = new Bytearrayinputstream (Bos.tobytearray ());
48. ObjectInputStream ois = new ObjectInputStream (bis);
50. return Ois.readobject ();
52. }
56. Public String getString () {
58. return string;
60. }
64. public void SetString (string string) {
66. this.string = string;
68. }
72. Public Serializableobject Getobj () {
74. return obj;
76. }
80. public void Setobj (Serializableobject obj) {
82. This.obj = obj;
84. }
88. }
92. Class Serializableobject implements Serializable {
94. Private static final long serialversionuid = 1L;
96. }

To implement a deep copy, you need to read the binary input of the current object in the form of a stream, and then write out the object corresponding to the binary data.

Five prototype patterns for Java Design patterns (Prototype)