Sometimes also known as cloning, basically the prototype is a generative design pattern that allows you to copy objects without making your code dependent on their classes.
Idea
The idea is to create a pack of monsters that will attack our hero/character. A specific configuration is set for enemies – Enemy config. With the help of the prototype, we will be able to copy the basic enemies and make groups of them. We can also copy groups and make up large units of them. We can set parameters, for example, 20 melee enemies and 40 ranged enemies. Based on the basic configuration, we can create copies of the units. That will further allow us to clone entire units. Cool, isn’t it?
Problem
Let’s say you have an Enemy object and you want to create an exact copy of it. How would you do it? First, we need to create a new object of the same class. Then you need to go through all the fields of the original object and copy their values to the new object.
Fine! But there is a catch. Not all objects can be copied in this way because some fields may be closed and not visible from outside the object itself.
There is another problem with the direct approach. Since we need to know the object’s class to create a duplicate, our code becomes dependent on that class. If other addiction doesn’t scare us, there is another snag. Sometimes you only know the interface that an object follows, but not its specific class, when, for example, a parameter in a method accepts any objects that follow some interface.
Solution
The Prototype template delegates the cloning process to natural cloned objects. The template declares a standard interface for all objects that support cloning. This interface allows you to clone an object without binding any code to the class of that object. Usually, such an interface contains only one clone method.
The implementation of the clone method in all classes is very similar. The method creates an object of the current class and transfers all the field values of the old object to the new one. You can even copy private fields because most programming languages allow objects to access the private fields of other objects belonging to the same class.
An object that supports cloning is called a prototype. When your objects have dozens of fields and hundreds of possible configurations, cloning them can be an alternative to subclassing.
Here’s how it works: you create a set of objects that are customizable in various ways. When you need an object like the one you customized, you clone the prototype instead of creating a new object from scratch.
Applicability
Use the prototype pattern when your code does not need to depend on the specific classes of objects that you need to copy.
This often happens when your code works with objects passed to you from third-party code through some interface. The specific classes of these objects are unknown, and you could not depend on them even if you wanted to.
The prototype template provides a common interface for client code to work with all objects that support cloning. This interface makes the client code independent of the specific classes of cloned objects.
The Prototype pattern allows you to use a set of pre-created objects, configured in various ways as prototypes.
Instead of instantiating a subclass to match some configuration, the client can find the appropriate prototype and clone it.
How to implement
Create a prototype interface and declare a clone method in it. Or add a method to all classes of the existing class hierarchy if you have one.
The prototype class must define an alternative constructor that takes an object of that class as an argument. The constructor must copy the values of all fields defined in the class from the passed object to the newly created instance. If you change the subclass, you must call the parent constructor to let the superclass handle cloning of its private fields. If your programming language does not support method overloading, you can define a special method to copy object data. The constructor is a more convenient place because it delivers the resulting object immediately after the call to the new operator.
The cloning method usually consists of one line: starting a new statement with a prototype constructor. Note that each class must explicitly override the clone method and use its class name along with the new operator. Otherwise, the clone method can create an object of the parent class.
Optionally, you can create a centralized prototype registry to store a catalog of frequently used prototypes. Using a static prototype fetch method, you can implement the registry as a new factory class or place it in the prototype base class. This method should search for a prototype based on the search criteria that the client code passes to the method. The requirements can be either a simple string tag or a complex set of search parameters. Once a matching prototype is found, the registry must clone it and return it to the client. Finally, replace direct calls to subclass constructors with calls to the prototype registry factory method.
Copying enemies
Let’s see how you can implement a prototype without the standard Cloneable interface.
Step 1: Let’s create a basic abstract class Enemy
Example 1:
Java
// Java Program to Create Abstract Enemy class// Abstract classpublic abstract class Enemy { // enemy health public int health; // enemy speed public int speed; // enemy name public String name; // Constructor 1 // Base constructor public Enemy() { } // Constructor 2 // Copy constructor public Enemy(Enemy target) { // Check that target not empty if (target != null) { // set base params and note // this keyword refers to current instance itself this.health = target.health; this.speed = target.speed; this.name = target.name; } } // clone() method public abstract Enemy clone(); // Override equals() method @Override public boolean equals(Object o) { if (!(o instanceof Enemy)) return false; Enemy enemy = (Enemy) o; return enemy.health == health && enemy.speed == speed && Objects.equals(enemy.name, name); } // Override hashCode() method @Override public int hashCode() { return Objects.hash(health, speed, name); }} |
Step 2: We need several enemies. Let it be ArcherEnemy and MeleeEnemy
Example 2-A
Java
// Let`s create ArcherEnemy with attack rangepublic class ArcherEnemy extends Enemy { // Enemy is a parent public int attackRange; // add new param public ArcherEnemy() { } public ArcherEnemy(ArcherEnemy target) { // clone constructor super(target); // first of all clone base Enemy if (target != null) { this.attackRange = target.attackRange; // then clone additional params } } /* Clone based on THIS enemy */ @Override public Enemy clone() { return new ArcherEnemy(this); } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; if (!super.equals(o)) return false; ArcherEnemy that = (ArcherEnemy) o; return attackRange == that.attackRange ; } @Override public int hashCode() { return Objects.hash(super.hashCode(), attackRange); }} |
Example 2-B
Java
// Let`s create MeleeEnemy with 'melee params'public class MeleeEnemy extends Enemy { public int blockChance; // add new param public boolean withShield; // add new param public MeleeEnemy() {} // Create clone constructor // clone base Enemy // and then clone additional params public MeleeEnemy(MeleeEnemy target) { super(target); if (target != null) { this.blockChance = target.blockChance; this.withShield = target.withShield; } } // Clone class based on current values @Override public Enemy clone() { return new MeleeEnemy(this); } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; if (!super.equals(o)) return false; MeleeEnemy that = (MeleeEnemy)o; return blockChance == that.blockChance && withShield == that.withShield; } @Override public int hashCode() { return Objects.hash(super.hashCode(), blockChance, withShield); }} |
Step 3: Let’s test the creation of clones as we have basic enemies ready.
Example 3:
Java
// Java Program to Illustrate Creation of Clones// Main classpublic class Demo { // Method 2 // Main driver method public static void main(String[] args) { // Creating enemy list List<Enemy> enemyList = new ArrayList<>(); // Creating enemy list copy List<Enemy> enemyListCopy = new ArrayList<>(); // Create baseArcher ArcherEnemy baseArcher = new ArcherEnemy(); // Setting attributes baseArcher.health = 150; baseArcher.speed = 35; baseArcher.name = "Base Archer"; baseArcher.attackRange = 100; enemyList.add(baseArcher); // Create clone baseArcher ArcherEnemy baseArcherClone = (ArcherEnemy)baseArcher.clone(); // Adding clone to enemyList enemyList.add(baseArcherClone); // Create baseMeleeEnemy MeleeEnemy baseMeleeEnemy = new MeleeEnemy(); // Setting attributes baseMeleeEnemy.health = 10; baseMeleeEnemy.speed = 20; baseMeleeEnemy.name = "blue"; baseMeleeEnemy.blockChance = 7; baseMeleeEnemy.withShield = true; // Now adding baseMeleeEnemy to enemyList // using add() method enemyList.add(baseMeleeEnemy); // Cloning whole list and comparing cloneAndCompare(enemyList, enemyListCopy); } // Method 1 // To clone and compare private static void cloneAndCompare(List<Enemy> enemyList, List<Enemy> enemyListCopy) { // Iterate over enemyList // using for-each loop for (Enemy enemy : enemyList) { // Clone enemys and add into enemyListCopy enemyListCopy.add(enemy.clone()); } // Compare enemies in enemyList and in enemyListCopy for (int i = 0; i < enemyList.size(); i++) { // Checking that enemy and cloneEnemy have // different links if (enemyList.get(i) != enemyListCopy.get(i)) { // Simply printing the result System.out.println( i + ": Enemy are different objects (yay!)"); // Check that they have same params if (enemyList.get(i).equals( enemyListCopy.get(i))) { // Print statement if they are identical System.out.println( i + ": And they are identical (yay!)"); } else { // Print statement if they are // not-identical System.out.println( i + ": But they are not identical (booo!)"); } } else { // Print statement if Shape objects are same System.out.println( i + ": Shape objects are the same (booo!)"); } } }} |
Output:
0: Enemy are different objects (yay!) // have different links 0: And they are identical (yay!) // but have same inner state 1: Enemy are different objects (yay!) // have different links 1: And they are identical (yay!) // but have same inner state 2: Enemy are different objects (yay!) // have different links 2: And they are identical (yay!) // but have same inner state
We got a list of enemies that we can copy and transfer to the client, if necessary. With this approach, we have the opportunity to use already created enemies and combine them into different groups, storing them in complex data structures.
