Specific analysis of prototype pattern in Java design patterns

This article mainly introduces the prototype pattern of design patterns. The editor thinks it is quite good. Now I will share it with you and give you a reference. Let’s follow the editor and take a look.

Definition: Use prototype instances to specify the types of objects to be created, and create new objects by copying these prototypes.

Type: Create a class pattern

Class diagram:

The prototype mode is mainly used for copying objects. Its core is the prototype class Prototype in the class diagram. The Prototype class needs to meet the following two conditions:

• Implement the Cloneable interface. There is a Cloneable interface in the Java language, which has only one function, which is to notify the virtual machine at runtime that it is safe to use the clone method on classes that implement this interface. In the Java virtual machine, only classes that implement this interface can be copied, otherwise a CloneNotSupportedException will be thrown at runtime.

• Override the clone method in the Object class. In Java, the parent class of all classes is the Object class. There is a clone method in the Object class, which is used to return a copy of the object. However, its scope is protected and cannot be called by ordinary classes. Therefore, the Prototype class needs to clone The scope of the method is changed to the public type.

The prototype pattern is a relatively simple pattern and very easy to understand. Implementing an interface and rewriting a method completes the prototype pattern. In practical applications, prototype patterns rarely appear alone. Often mixed with other patterns, its prototype class Prototype is often replaced by abstract classes.

Implementation code:

##

class Prototype implements Cloneable { 
  public Prototype clone(){ 
    Prototype prototype = null; 
    try{ 
      prototype = (Prototype)superclone(); 
    }catch(CloneNotSupportedException e){ 
      e.printStackTrace(); 
    } 
    return prototype;  
  } 
} 
 
class ConcretePrototype extends Prototype{ 
  public void show(){ 
    System.out.println("原型模式实现类"); 
  } 
} 
 
public class Client { 
  public static void main(String[] args){ 
    ConcretePrototype cp = new ConcretePrototype(); 
    for(int i=0; i< 10; i++){ 
      ConcretePrototype clonecp = (ConcretePrototype)cpclone(); 
      clonecp.show(); 
    } 
  } 
}

Advantages and applicable scenarios of prototype mode

Using the prototype mode to create an object is much better in performance than directly new an object, because the clone method of the Object class is a local method, which directly operates the binary stream in the memory, especially when copying large objects, the performance difference very obvious.

Another benefit of using the prototype pattern is to simplify the creation of objects, making creating objects as simple as copying and pasting when we edit a document.

Because of the above advantages, you can consider using the prototype pattern when you need to repeatedly create similar objects. For example, if you need to create an object within a loop body, if the object creation process is complex or the number of loops is large, using the prototype pattern can not only simplify the creation process, but also greatly improve the overall performance of the system.

Notes on prototype mode

• Copying an object using prototype mode will not call the constructor of the class. Because the copy of the object is completed by calling the clone method of the Object class, it copies the data directly in the memory, so the constructor of the class is not called. Not only will the code in the constructor not be executed, but even the access permissions will be invalid for prototype mode. Remember the singleton pattern? In the singleton mode, as long as the access permission of the constructor is set to private, a singleton can be implemented. However, the clone method directly ignores the permissions of the constructor method. Therefore, the singleton mode conflicts with the prototype mode, so special attention should be paid when using it.

• Deep copy and shallow copy. The clone method of the Object class will only copy the basic data types in the object. Arrays, container objects, reference objects, etc. will not be copied. This is a shallow copy. If you want to implement deep copy, you must copy the array, container object, reference object, etc. in the prototype mode separately. For example:

public class Prototype implements Cloneable { 
  private ArrayList list = new ArrayList(); 
  public Prototype clone(){ 
    Prototype prototype = null; 
    try{ 
      prototype = (Prototype)superclone(); 
      prototype.list = (ArrayList) this.list.clone(); 
    }catch(CloneNotSupportedException e){ 
      e.printStackTrace(); 
    } 
    return prototype;  
  } 
}

Since ArrayList is not a basic type, the member variable list will not be copied and we need to implement deep copy ourselves. Fortunately Most of the container classes provided by Java implement the Cloneable interface. So implementing deep copy is not particularly difficult.

The above is the detailed content of Specific analysis of prototype pattern in Java design patterns. For more information, please follow other related articles on the PHP Chinese website!