对象复制的魔法——探索原型模式的魅力

原创

码匠er

发布于 2024-03-01 20:45:11

620

发布于 2024-03-01 20:45:11

文章被收录于专栏：设计模式设计模式

原型模式很简单，通过原型模式，你可以克隆出多个一模一样的对象

1. 定义

原型模式是使用原型实例指定创建对象的种类，并且通过克隆这些原型创建新的对象。

2. 结构

Prototype：抽象原型类声明了克隆方法的接口，是具体原型类的父类
ConcretePrototype：具体原型类实现了抽象原型类中声明的克隆方法，该方法返回一个自己的克隆对象
Client:客户类让一个原型类克隆自身，从而创建新的对象

3. 设计原理

原型模式的设计原理是客户端将调用原型对象的克隆方法自己实现创建过程。原型对象的核心就是对象克隆。

4. 案例分析

假如我们需要开发一款游戏，我们需要生成许多怪物，我们可以使用原型对象对怪物进行创建和管理。

抽象原型对象：

 public abstract class Monster implements Cloneable {
     private String name;
     private int HP; // 生命值
 
     public Monster(String name, int HP) {
         this.name = name;
         this.HP = HP;
     }
 
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     public int getHP() {
         return HP;
     }
 
     public void setHP(int HP) {
         this.HP = HP;
     }

具体原型对象：

 public class Goblin extends Monster{
 
     public Goblin(String name, int HP) {
         super(name, HP);
     }
 
    @Override
     protected Goblin clone() {
         Object obj = null;
         try {
             obj = super.clone();
             return (Goblin) obj;
         } catch (CloneNotSupportedException e) {
             e.printStackTrace();
         }
         return null;
     }
 }

客户端：

 public class Client {
     public static void main(String[] args) {
         // 先创建一个小妖精
         Goblin goblin = new Goblin("小妖精", 100);
         System.out.println(goblin.getName());
         System.out.println(goblin.getHP());
         // 通过原型创建一个新的妖精
         Goblin newGobin = goblin.clone();
         System.out.println(newGobin.getName());
         System.out.println(newGobin.getHP());
         // 自己给妖精设置属性
         newGobin.setName("大妖精");
         newGobin.setHP(500);
         System.out.println("小妖精的名字：" + goblin.getName() + "; 小妖精的生命值：" + goblin.getHP());
         System.out.println("新妖精的名字：" + newGobin.getName() + "; 新妖精的生命值：" + newGobin.getHP());
     }
 }

创建新的怪物对象时，不需要重新使用new关键字创建，直接克隆。

我们可以看到我们很快就创建了一个独立的对象，而且和之前的原型对象是独立的。

下面需要进行优化，每个怪物都有自身独有的技能，我们改造一下代码。

 public class Skilledness {
     private String name;
     private int damage;
 
     public Skilledness(String name, int damage) {
         this.name = name;
         this.damage = damage;
     }
 
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     public int getDamage() {
         return damage;
     }
 
     public void setDamage(int damage) {
         this.damage = damage;
     }
 
     @Override
     public String toString() {
         return "Skilledness{" +
                 "name='" + name + '\'' +
                 ", damage=" + damage +
                 '}';
     }
 }

 public abstract class Monster implements Cloneable {
     private String name;
     private int HP; // 生命值
     // 新增技能属性
     private Skilledness skilledness;
 
     public Monster(String name, int HP) {
         this.name = name;
         this.HP = HP;
     }
 
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     public int getHP() {
         return HP;
     }
 
     public void setHP(int HP) {
         this.HP = HP;
     }
 
     public Skilledness getSkilledness() {
         return skilledness;
     }
 
     public void setSkilledness(Skilledness skilledness) {
         this.skilledness = skilledness;
     }
 }

 public class Orge extends Monster{
 
     public Orge(String name, int HP) {
         super(name, HP);
     }
 
     @Override
     protected Orge clone() {
         Object obj = null;
         try {
             obj = super.clone();
             return (Orge) obj;
         } catch (CloneNotSupportedException e) {
             e.printStackTrace();
         }
         return null;
     }
 }

客户端：

 public class Client {
     public static void main(String[] args) {
         // 先创建一个恶魔
         Orge orge = new Orge("大恶魔", 1000);
         // 给恶魔设置一个技能
         Skilledness skilledness = new Skilledness("鬼斩", 200);
         orge.setSkilledness(skilledness);
         // 再创建一个恶魔
         Orge orge1 = orge.clone();
         System.out.println("新恶魔名称:" + orge1.getName());
         System.out.println("新恶魔生命值:" + orge1.getHP());
         System.out.println("新恶魔技能:" + orge1.getSkilledness());
         // 修改技能
         orge1.getSkilledness().setDamage(300);
         // 查看技能伤害值
         // 为什么复制的技能伤害值改变，原来的技能伤害值也改变了？
         System.out.println("原恶魔伤害:" + orge.getSkilledness().getDamage());
         System.out.println("新恶魔伤害:" + orge1.getSkilledness().getDamage());
     }
 }

5. 深拷贝和浅拷贝

上面的代码中，我们可以看出，技能在复制时，新的技能改变，原来的技能值也改变了，这并不是我们想要的结果，这个是为什么呢？我们应该怎么实现对技能真正的复制呢？

回答上面的代码之前，需要先了解两种不同的克隆方法，分别是深拷贝和浅拷贝。

浅拷贝：创建一个新的对象，然后将原始对象的非静态字段的值赋值到新的对象，如果包含引用对象，则将引用对象的地址复制一份给克隆的对象，也就是说新的对象和原对象的成员变量指向相同的内存地址。

上面代码中都属于浅拷贝的实现，所以当新的技能值改变之后，原来的技能值也会发生改变。

深拷贝：创建一个新的对象，并且递归的复制原始对象及所有引用类型的成员变量，使得新的对象和原对象完全独立。深拷贝建创建的对象和相关的对象都是新的，不是共享同一引用。

在Java语言中，深拷贝的实现可以考虑使用序列化等方式。通过将对象序列化成字节流，然后再将字节流反序列化为新的对象。下面是实现对技能的深拷贝实现。

因为需要实现序列化，所以怪物类和技能类都需要实现Serializable接口,这里就不单独展示了。

 public class Orge extends Monster {
 
     public Orge(String name, int HP) {
         super(name, HP);
     }
 
     protected Orge deepClone() throws IOException, ClassNotFoundException {
         // 序列化为字节流
         ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
         ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
         objectOutputStream.writeObject(this);
         // 反序列化
         ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
         ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
        return (Orge) objectInputStream.readObject();
     }
 }

public class Client {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 先创建一个恶魔
        Orge orge = new Orge("大恶魔", 1000);
        // 给恶魔设置一个技能
        Skilledness skilledness = new Skilledness("鬼斩", 200);
        orge.setSkilledness(skilledness);
        // 再创建一个恶魔
        Orge orge1 = orge.deepClone();
        System.out.println("新恶魔名称:" + orge1.getName());
        System.out.println("新恶魔生命值:" + orge1.getHP());
        System.out.println("新恶魔技能:" + orge1.getSkilledness());
        // 修改技能
        orge1.getSkilledness().setDamage(300);
        // 查看技能伤害值
        // 新恶魔伤害值修改了，但是原恶魔伤害值没有修改，深拷贝成功
        System.out.println("原恶魔伤害:" + orge.getSkilledness().getDamage());
        System.out.println("新恶魔伤害:" + orge1.getSkilledness().getDamage());
    }
}

6.UML图

7. 原型管理器

原型管理器是将多个原型对象存储在一个集合中供客户端使用，它是专门负责创建对象的工厂。

public class MonsterManager {
    private static Map<String, Monster> monsterMap = new HashMap<>();

    static {
        monsterMap.put("Goblin", new Goblin("Small Goblin", 100));
        monsterMap.put("Orge", new Goblin("Big Goblin", 1000));
    }

    public static Monster getMonster(String type) {
        Monster monster = monsterMap.get(type);
        return monster != null ? monster.clone() : null;
    }

    public static void addMonster(String type, Monster monster) {
        monsterMap.put(type, monster);
    }
}