Java prototype mode (prototype)

To understand the prototype mode, you must first understand the shortest replication and deep replication in Java. In some cases, replication is also called cloning. Java provides these two cloning methods.

Shortest: all the variables of the cloned object contain the same value as the original object, and all its references to other objects still point to the original object. In other words, the shortest clone only clones the objects to be considered, rather than the objects referenced by it.

Deep clone: all the variables of the cloned object contain the same value as the original object, but all its references to other objects are no longer original, this is a new object that has been copied. In other words, deep replication copies all referenced objects of the objects to be copied. This is called indirect replication. The source code of deep replication is as follows: Java code

1. Public object deepclone () throws ioexception, optionaldataexception, classnotfoundexception
3. {
5. // Write to stream
7. Bytearrayoutputstream BO = new bytearrayoutputstream ();
9. Objectoutputstream oo = new objectoutputstream (BO );
11. OO. writeobject (this); // read from stream bytearrayinputstream Bi = new bytearrayinputstream (BO. tobytearray ());
13. Objectinputstream OI = new objectinputstream (BI );
15. Return (OI. readobject ());
17. }

Public object deepclone () throws ioexception, optionaldataexception, classnotfoundexception {// write to stream bytearrayoutputstream BO = new topology (); objectoutputstream oo = new objectoutputstream (BO); oo. writeobject (this); // read from stream bytearrayinputstream Bi = new bytearrayinputstream (BO. tobytearray (); objectinputstream OI = new objectinputstream (BI); Return (OI. readobject ());}

The build model of the Java language directly supports the prototype model. All classes to be cloned must implement a cloneable interface. All classes have a clone () method (provided by the object ). Cloning meets the following conditions: X. Clone () exists for any object X ()! = X, in other words, the cloned object is not the original object; X. clone (). getclass () = x. getclass (). In other words, the cloned object is of the same type as the original object. X. Clone (). Equals (X) is set up. Java code

1. Public class sheep implements cloneable
3. {
5. Private string name = "Dolly ";
7. Public object clone () throws clonenotsupportedexception
9. {
11. Return super. Clone ();
13. }
15. }

Public class sheep implements cloneable {private string name = "Dolly"; public object clone () throws clonenotsupportedexception {return Super. Clone ();}}

Prototype mode definition: Use a prototype instance to specify the type of the object to be created, and copy the prototype to create a new object.

The prototype mode allows an object to create another custom object without any details. The working principle is: pass a prototype object to the object to be created, the objects to be created are created by requesting the prototype objects to copy themselves.

How to use it? Because the clone () method is provided in Java to clone objects, prototype implementation becomes very simple.

Using a spoon as an example: Java code

1. Public abstract class abstractspoon implements cloneable
2. {
3. String spoonname;
5. Public void setspoonname (string spoonname) {This. spoonname = spoonname ;}
6. Public String getspoonname () {return this. spoonname ;}
8. Public object clone ()
9. {
10. Object object = NULL;
11. Try {
12. Object = super. Clone ();
13. } Catch (clonenotsupportedexception exception ){
14. System. Err. println ("abstractspoon is not cloneable ");
15. }
16. Return object;
17. }
18. }
19. There is a specific implementation (concreteprototype ):
21. Public class soupspoon extends actspoon
22. {
23. Public soupspoon ()
24. {
25. Setspoonname ("soup spoon ");
26. }
27. }

Public abstract class implements actspoon implements cloneable {string spoonname; Public void setspoonname (string spoonname) {This. spoonname = spoonname;} Public String getspoonname () {return this. spoonname;} public object clone () {object = NULL; try {object = super. clone ();} catch (clonenotsupportedexception exception) {system. err. println ("abstractspoon is not cloneable");} return object;} has a specific implementation (concreteprototype): Public class soupspoon extends actspoon {public soupspoon () {setspoonname ("soup spoon ");}}

It is easy to call the prototype mode:

Abstractspoon spoon = new soupspoon ();
Abstractspoon spoon2 = spoon. Clone ();
Of course, you can also create a abstractspoon instance in the factory mode.

In Java, the prototype mode becomes the use of the clone () method. The pure object-oriented feature of Java makes it natural to use the design mode in Java, the two are almost integrated. This is reflected in many modes, such as the interator traversal mode.

 

From: http://sakyone.iteye.com/blog/484099