背景
假设我们有一个游戏中的敌人类 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