Android design mode series-prototype mode

CV A family, it should be easy to understand the prototype model of the principle, copy, after pasting to see if the specific situation is modified, in fact, this is the prototype model.
From the Java point of view, the general use of prototype mode has an obvious feature is to implement the Cloneable clone () method.
Prototype mode to quickly clone a new object that is similar to the one that already exists.

1. Intentions
Use the prototype instance to specify the kind of object to create and create a new object by copying the prototypes.
Hot words: clone deep copy shallow copy

2. Structure diagram and code
Its structure diagram is very simple, we take intent as an example:

The Clone method of intent is very simple:

1. @Override
2. Public Object Clone () {
3. return New Intent (this);
4. }

Returns a new intent object.
Cloning operation of deep copy and shallow copy, shallow copy is the original object all the values and references directly to the new object. Deep copy not only assigns the value of the original object to the new object, but also re-creates the reference object of the original object again and assigns it to the new object.
Let's analyze whether the intent is a shallow copy or a deep copy:

2. Public Intent (Intent o) {
4. this.maction = o.maction;
6. this.mdata = O.mdata;
8. this.mtype = O.mtype;
10. this.mpackage = o.mpackage;
12. this.mcomponent = o.mcomponent;
14. this.mflags = o.mflags;
16. ///The following is a reference object that has been recreated, is a deep copy
18. if (o.mcategories! = null) {
20. this.mcategories = new hashset<string> (o.mcategories);
22. }
24. if (o.mextras! = null) {
26. This.mextras = new Bundle (O.mextras);
28. }
30. if (o.msourcebounds! = null) {
32. this.msourcebounds = new Rect (o.msourcebounds);
34. }
36. }

Here's why we intent to rewrite the Clone method of object, which is related to the deep copy.
In fact, we look at the Clone () method of object source code and comments, the default Super.clone () is a shallow copy:

2. /**
4. * Creates and returns a copy of this {@code Object}. The default
6. * Implementation returns a so-called "shallow" copy:it creates a new
8. * Instance of the same class and then copies the field values (including
10. * Object references) from this instance to the new instance. A "Deep" copy,
12. * In contrast, would also recursively clone nested objects. A Subclass that
14. * Needs to implement the kind of cloning should call {@code super.clone ()}
16. * To create the new instance and then create a deep copies of the nested,
18. * mutable objects.
20. */
22. Protected Object Clone () throws clonenotsupportedexception {
24. if (! ( this instanceof cloneable)) {  
26. throw New Clonenotsupportedexception ("Class doesn ' t implement cloneable");
28. }
32. return Internalclone ((cloneable) this );
34. }

This form is a prototype pattern in a simple form, and if the number of prototypes that need to be created is not fixed, you can create a prototype manager that the client will view in the prototype manager before copying the prototype object.
If there is a prototype object that satisfies the condition, if there is one, use it directly, if not, clone a prototype pattern called the registration form.
A prototype model can be used to hide a specific class of products from the customer, thus reducing the number of names the customer knows, and the customer does not need to change
The flaw in prototype mode is that the subclass of each prototype must implement the Cloneable interface, which is sometimes difficult to implement.

3. Effects
(1). Create pattern
(2). Add and remove products at run time
(3). Change only to specify new objects (Ctrl + V, then modify)
(4). Change the structure to specify a new object. (Similar to 2, implementation is different)
(5). Reduce the construction of sub-classes

Android design mode series-prototype mode