《Java 原型模式：克隆大师的奇妙冒险》

装睡鹿先生
167 阅读4分钟

嘿，各位 Java 大侠们！今天咱继续来聊聊超有趣的 Java 设计模式 —— 原型模式。这就如同在编程江湖中，有一位神秘的克隆大师，能迅速变出好多相似的宝贝。

一、啥是原型模式？

想象一下，你正在玩一款游戏，有一个超级厉害的武器，现在你想快速复制出几个一模一样的来，增强自己的实力。这时候原型模式就像魔法一样出现啦！它的核心思想就是通过复制一个已有的对象来创建新对象，而不是费劲地从头开始创建。就像孙悟空拔根毫毛变出一群小猴子一样，高效又方便。

在 Java 中，实现原型模式主要是靠实现Cloneable接口，然后重写clone()方法。这个clone()方法就像是神奇的魔法咒语，一念就能变出一个和原来对象一模一样的新对象。

二、怎么用原型模式呢？

首先，让我们的类实现Cloneable接口，这就相当于给这个类赋予了克隆的超能力。然后，重写clone()方法。在这个方法里，我们要小心翼翼地复制对象的各个属性，确保新对象和原对象一模一样。

比如说，我们有个 “宠物小精灵” 类：

class Pokemon implements Cloneable {
    private String name;
    private int level;
    private String type;
    public Pokemon(String name, int level, String type) {
        this.name = name;
        this.level = level;
        this.type = type;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setLevel(int level) {
        this.level = level;
    }
    public void setType(String type) {
        this.type = type;
    }
    @Override
    public String toString() {
        return "Pokemon{" +
                "name='" + name + ''' +
                ", level=" + level +
                ", type='" + type + ''' +
                '}';
    }
    @Override
    public Pokemon clone() {
        try {
            return (Pokemon) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

现在，我们可以这样使用原型模式：

public class PrototypeDemo {
    public static void main(String[] args) {
        Pokemon pikachu = new Pokemon("Pikachu", 10, "Electric");
        System.out.println("Original Pokemon: " + pikachu);
        Pokemon clonedPikachu = pikachu.clone();
        clonedPikachu.setName("Cloned Pikachu");
        clonedPikachu.setLevel(8);
        System.out.println("Cloned Pokemon: " + clonedPikachu);
    }
}

瞧，我们轻松地复制出了一个宠物小精灵！而且还可以修改克隆出来的小精灵的属性，而不影响原来的小精灵。

再举个例子，比如我们有个 “汽车” 类：

class Car implements Cloneable {
    private String brand;
    private int speed;
    private String color;
    public Car(String brand, int speed, String color) {
        this.brand = brand;
        this.speed = speed;
        this.color = color;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public void setSpeed(int speed) {
        this.speed = speed;
    }
    public void setColor(String color) {
        this.color = color;
    }
    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + ''' +
                ", speed=" + speed +
                ", color='" + color + ''' +
                '}';
    }
    @Override
    public Car clone() {
        try {
            return (Car) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

使用方法如下：

public class PrototypeDemo {
    public static void main(String[] args) {
        Car ferrari = new Car("Ferrari", 300, "Red");
        System.out.println("Original Car: " + ferrari);
        Car clonedFerrari = ferrari.clone();
        clonedFerrari.setBrand("Cloned Ferrari");
        clonedFerrari.setSpeed(250);
        clonedFerrari.setColor("Blue");
        System.out.println("Cloned Car: " + clonedFerrari);
    }
}

三、原型模式有啥好处呢？

  1. 高效创建对象：不用每次都从头开始创建对象，节省了时间和资源。比如我们要创建很多类似的宠物小精灵或者汽车，用原型模式就可以快速复制，而不是一个一个地构造。
  1. 独立性：克隆出来的对象和原对象相互独立，修改一个不会影响另一个。就像我们的克隆皮卡丘可以有自己的名字和等级，和原来的皮卡丘互不干扰。

四、注意事项

  1. 深克隆和浅克隆：默认的clone()方法是浅克隆，只复制对象的基本类型和引用类型的引用，而不复制引用指向的对象。如果需要深克隆，就得自己手动复制引用指向的对象。

比如说，如果我们的 “宠物小精灵” 类中有一个 “技能” 类的引用：

class Skill {
    private String name;
    public Skill(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Skill{" +
                "name='" + name + ''' +
                '}';
    }
}
class Pokemon implements Cloneable {
    private String name;
    private int level;
    private String type;
    private Skill skill;
    public Pokemon(String name, int level, String type, Skill skill) {
        this.name = name;
        this.level = level;
        this.type = type;
        this.skill = skill;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setLevel(int level) {
        this.level = level;
    }
    public void setType(String type) {
        this.type = type;
    }
    public void setSkill(Skill skill) {
        this.skill = skill;
    }
    @Override
    public String toString() {
        return "Pokemon{" +
                "name='" + name + ''' +
                ", level=" + level +
                ", type='" + type + ''' +
                ", skill=" + skill +
                '}';
    }
    @Override
    public Pokemon clone() {
        try {
            Pokemon cloned = (Pokemon) super.clone();
            cloned.skill = new Skill(cloned.skill.getName());
            return cloned;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

这样我们在克隆 “宠物小精灵” 对象时，也会复制 “技能” 对象，实现深克隆。

  1. 异常处理：在重写clone()方法时，要处理好CloneNotSupportedException异常，不然程序可能会出问题哦。

好啦，各位 Java 大侠们，现在你们对原型模式是不是有了更深刻的认识呢？快去试试这个神奇的克隆大师吧，让你的编程之旅更加精彩！😎

如果你觉得这篇文章有用，别忘了点赞、评论、分享哦！让更多的小伙伴一起探索 Java 设计模式的奇妙世界。💻🚀

avatar
文章
阅读
粉丝