【设计模式|创建型】原型模式（Prototype Pattern）

背景

假设我们有一个游戏中的敌人类 Enemy，每个敌人都有一个独特的外观和属性。在游戏中，敌人的数量可能非常多，而且每个敌人的创建过程可能比较复杂。这时，我们可以使用原型模式来创建敌人对象。

解释

原型模式（Prototype Pattern）是一种创建型设计模式，它允许我们通过复制（克隆）已有对象来创建新对象，而无需从头开始构建一个对象。通过克隆已有对象，原型模式能够节省创建对象的时间和资源，并且能够方便地创建具有复杂内部结构的对象。

示例一

首先，我们创建一个 Enemy 接口，其中定义了一个克隆方法：

public interface Enemy extends Cloneable {
    Enemy clone();
    void display();
}

然后，我们创建一个具体的 Enemy 类，实现了克隆方法和 display 方法：

public class ConcreteEnemy implements Enemy {
    private String appearance;
    private String attribute;

    public ConcreteEnemy(String appearance, String attribute) {
        this.appearance = appearance;
        this.attribute = attribute;
    }

    @Override
    public Enemy clone() {
        return new ConcreteEnemy(this.appearance, this.attribute);
    }

    @Override
    public void display() {
        System.out.println("Enemy: " + appearance + ", Attribute: " + attribute);
    }
}

接下来，我们创建一个 EnemyManager 类，用于管理敌人对象的创建和复用：

public class EnemyManager {
    private Map<String, Enemy> enemyMap;

    public EnemyManager() {
        enemyMap = new HashMap<>();
    }

    public void addEnemy(String key, Enemy enemy) {
        enemyMap.put(key, enemy);
    }

    public Enemy getEnemy(String key) {
        Enemy enemy = enemyMap.get(key);
        if (enemy != null) {
            return enemy.clone();
        }
        return null;
    }
}

最后，我们可以在客户端代码中使用 EnemyManager 来创建和复用敌人对象：

public class Client {
    public static void main(String[] args) {
        EnemyManager enemyManager = new EnemyManager();

        // 创建敌人对象并添加到管理器中
        Enemy enemy1 = new ConcreteEnemy("Enemy 1", "Attribute 1");
        enemyManager.addEnemy("Enemy 1", enemy1);

        // 从管理器中获取敌人对象并显示
        Enemy clonedEnemy1 = enemyManager.getEnemy("Enemy 1");
        clonedEnemy1.display();

        // 创建另一个敌人对象并添加到管理器中
        Enemy enemy2 = new ConcreteEnemy("Enemy 2", "Attribute 2");
        enemyManager.addEnemy("Enemy 2", enemy2);

        // 从管理器中获取另一个敌人对象并显示
        Enemy clonedEnemy2 = enemyManager.getEnemy("Enemy 2");
        clonedEnemy2.display();
    }
}

运行结果：

Enemy: Enemy 1, Attribute: Attribute 1
Enemy: Enemy 2, Attribute: Attribute 2

示例二

以下是一个实际应用中的场景示例，以创建动物的克隆对象为例：

首先，定义一个抽象类Animal，作为原型对象：

public abstract class Animal implements Cloneable {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    // 定义抽象方法，用于创建动物的克隆对象
    public abstract Animal clone();
}

接下来，定义具体的动物类，例如Cat和Dog，继承自Animal类：

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    @Override
    public Animal clone() {
        return new Cat(getName());
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public Animal clone() {
        return new Dog(getName());
    }
}

然后，创建一个动物缓存类AnimalCache，用于缓存已有的动物对象，并提供获取克隆对象的方法：

public class AnimalCache {
    private static Map<String, Animal> cache = new HashMap<>();

    public static void loadCache() {
        Cat cat = new Cat("Tom");
        cache.put(cat.getName(), cat);

        Dog dog = new Dog("Max");
        cache.put(dog.getName(), dog);
    }

    public static Animal getAnimal(String name) {
        Animal animal = cache.get(name);
        if (animal != null) {
            return animal.clone();
        }
        return null;
    }
}

最后，使用原型模式创建动物克隆对象的示例：

public class Main {
    public static void main(String[] args) {
        AnimalCache.loadCache();

        Animal cat1 = AnimalCache.getAnimal("Tom");
        if (cat1 != null) {
            System.out.println("Cat 1: " + cat1.getName());
        }

        Animal cat2 = AnimalCache.getAnimal("Tom");
        if (cat2 != null) {
            System.out.println("Cat 2: " + cat2.getName());
        }

        Animal dog = AnimalCache.getAnimal("Max");
        if (dog != null) {
            System.out.println("Dog: " + dog.getName());
        }
    }
}

运行结果：

Cat 1: Tom
Cat 2: Tom
Dog: Max