原型模式 实际项目 示例 java
时间: 2023-09-02 17:07:12 浏览: 45
原型模式是一种创建型设计模式,它允许通过克隆现有对象来创建新对象,而无需从头开始构建。
在实际项目中,原型模式可以用于以下场景:
1. 对象的构建过程比较复杂,但新对象与现有对象之间的差异比较小,可以通过克隆来节省时间和资源。
2. 需要在运行时动态创建对象,并且无法确定对象的类型。在这种情况下,可以使用原型模式来克隆一个模板对象,然后根据需要修改其属性。
下面是一个使用原型模式的示例,假设我们正在开发一个游戏,其中有多种类型的敌人。我们可以使用原型模式来创建不同类型的敌人。
首先,我们需要定义一个抽象类 Enemy,它包含敌人的共同属性和方法:
```
public abstract class Enemy implements Cloneable {
private String name;
private int health;
private int damage;
public Enemy(String name, int health, int damage) {
this.name = name;
this.health = health;
this.damage = damage;
}
public String getName() {
return name;
}
public int getHealth() {
return health;
}
public int getDamage() {
return damage;
}
public void attack() {
System.out.println(name + " attacks and deals " + damage + " damage!");
}
@Override
public Enemy clone() throws CloneNotSupportedException {
return (Enemy) super.clone();
}
}
```
然后,我们可以定义具体的敌人类型,例如 Orc 和 Skeleton:
```
public class Orc extends Enemy {
public Orc() {
super("Orc", 100, 20);
}
}
public class Skeleton extends Enemy {
public Skeleton() {
super("Skeleton", 50, 10);
}
}
```
现在,我们可以使用原型模式来创建不同类型的敌人。我们先创建一个 EnemyFactory 类,它包含了一个敌人对象的缓存:
```
import java.util.HashMap;
import java.util.Map;
public class EnemyFactory {
private static Map<String, Enemy> cache = new HashMap<>();
static {
cache.put("Orc", new Orc());
cache.put("Skeleton", new Skeleton());
}
public static Enemy getEnemy(String type) throws CloneNotSupportedException {
return cache.get(type).clone();
}
}
```
最后,我们可以在游戏中使用 EnemyFactory 来创建不同类型的敌人:
```
public class Game {
public static void main(String[] args) throws CloneNotSupportedException {
Enemy orc1 = EnemyFactory.getEnemy("Orc");
Enemy orc2 = EnemyFactory.getEnemy("Orc");
Enemy skeleton1 = EnemyFactory.getEnemy("Skeleton");
Enemy skeleton2 = EnemyFactory.getEnemy("Skeleton");
orc1.attack(); // Orc attacks and deals 20 damage!
orc2.attack(); // Orc attacks and deals 20 damage!
skeleton1.attack(); // Skeleton attacks and deals 10 damage!
skeleton2.attack(); // Skeleton attacks and deals 10 damage!
}
}
```
在这个示例中,我们使用原型模式来创建不同类型的敌人。EnemyFactory 充当了对象缓存的角色,可以根据需要返回已有的敌人对象或者克隆一个新的敌人对象。这样,我们就可以方便地创建不同类型的敌人,而无需重复构建相同的对象。