原型模式（java）

原型模式（Prototype Pattern） 是指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象

调用者不需要知道任何创建细节，不调用构造函数

属于创建型模式

1、类初始化消耗资源较多

2、new产生的一个对象需要非常繁琐的过程（数据准备、访问权限等）

3、构造函数比较复杂

4、循环体中生产大量对象时

1. 原型模式概述

原型模式（Prototype Pattern） 是一种创建型设计模式，它通过复制现有对象来创建新对象，而不是通过new关键字实例化。这种方式避免了重复初始化的开销，特别适用于创建成本较高的对象（如数据库查询、复杂计算等）。

核心思想

• 不直接new对象，而是通过克隆（Clone）现有对象来创建新对象。
• 适用于对象初始化成本高或需要动态配置对象的场景。

---

2. 原型模式的实现方式

在Java中，原型模式主要通过**Cloneable接口和Object.clone()方法**实现。

2.1 Cloneable接口

• Cloneable 是一个标记接口（没有方法），表示该类的对象可以被克隆。
• 如果一个类没有实现Cloneable，调用clone()方法会抛出CloneNotSupportedException。

2.2 Object.clone()方法

• Object类提供了clone()方法，默认是浅拷贝（Shallow Copy）。
• 如果类包含引用类型字段，浅拷贝只会复制引用，而不会复制引用指向的对象。

3. 原型模式的两种拷贝方式

3.1 浅拷贝（Shallow Copy）

• 只复制基本数据类型和引用地址，不复制引用指向的对象。
• 如果原对象和克隆对象修改了引用类型字段，会影响彼此。

示例代码（浅拷贝）

class Person implements Cloneable {
    private String name;
    private Address address; // 引用类型

    public Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // 默认是浅拷贝
    }

    // Getter & Setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public Address getAddress() { return address; }
    public void setAddress(Address address) { this.address = address; }
}

class Address {
    private String city;

    public Address(String city) {
        this.city = city;
    }

    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }
}

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("Beijing");
        Person person1 = new Person("Alice", address);
        Person person2 = (Person) person1.clone(); // 浅拷贝

        System.out.println(person1.getAddress().getCity()); // Beijing
        System.out.println(person2.getAddress().getCity()); // Beijing

        person2.getAddress().setCity("Shanghai"); // 修改克隆对象的地址

        System.out.println(person1.getAddress().getCity()); // Shanghai（原对象也被修改）
        System.out.println(person2.getAddress().getCity()); // Shanghai
    }
}

输出：

Beijing
Beijing
Shanghai
Shanghai

结论：person1和person2共享同一个Address对象，修改其中一个会影响另一个。

---

3.2 深拷贝（Deep Copy）

• 不仅复制基本数据类型和引用地址，还会递归复制引用指向的对象。
• 原对象和克隆对象完全独立，修改彼此不会影响对方。

实现深拷贝的方式

1. 手动实现clone()方法，递归调用引用对象的clone()。
2. 使用序列化（Serialization），通过ObjectOutputStream和ObjectInputStream实现深拷贝。

示例代码（手动深拷贝）

class Person implements Cloneable {
    private String name;
    private Address address;

    public Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person cloned = (Person) super.clone(); // 先复制基本类型和引用
        cloned.address = (Address) address.clone(); // 手动克隆引用对象
        return cloned;
    }

    // Getter & Setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public Address getAddress() { return address; }
    public void setAddress(Address address) { this.address = address; }
}

class Address implements Cloneable {
    private String city;

    public Address(String city) {
        this.city = city;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }
}

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("Beijing");
        Person person1 = new Person("Alice", address);
        Person person2 = (Person) person1.clone(); // 深拷贝

        System.out.println(person1.getAddress().getCity()); // Beijing
        System.out.println(person2.getAddress().getCity()); // Beijing

        person2.getAddress().setCity("Shanghai"); // 修改克隆对象的地址

        System.out.println(person1.getAddress().getCity()); // Beijing（原对象不受影响）
        System.out.println(person2.getAddress().getCity()); // Shanghai
    }
}

输出：

Beijing
Beijing
Beijing
Shanghai

结论：person1和person2的Address对象是独立的，修改其中一个不会影响另一个。

示例代码（序列化实现深拷贝）

import java.io.*;

class Person implements Serializable {
    private String name;
    private Address address;

    public Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    public Person deepCopy() throws IOException, ClassNotFoundException {
        // 序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);

        // 反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return (Person) ois.readObject();
    }

    // Getter & Setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public Address getAddress() { return address; }
    public void setAddress(Address address) { this.address = address; }
}

class Address implements Serializable {
    private String city;

    public Address(String city) {
        this.city = city;
    }

    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }
}

public class Main {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Address address = new Address("Beijing");
        Person person1 = new Person("Alice", address);
        Person person2 = person1.deepCopy(); // 深拷贝

        System.out.println(person1.getAddress().getCity()); // Beijing
        System.out.println(person2.getAddress().getCity()); // Beijing

        person2.getAddress().setCity("Shanghai"); // 修改克隆对象的地址

        System.out.println(person1.getAddress().getCity()); // Beijing（原对象不受影响）
        System.out.println(person2.getAddress().getCity()); // Shanghai
    }
}

输出：

Beijing
Beijing
Beijing
Shanghai

结论：序列化方式也能实现深拷贝，但性能较低（适用于复杂对象）。

---

4. 原型模式的优缺点

优点

✅ 避免重复初始化：适用于创建成本高的对象（如数据库查询、复杂计算）。
✅ 动态配置对象：可以在运行时动态修改克隆对象的属性。
✅ 减少子类数量：避免使用工厂模式创建大量子类。

缺点

❌ 实现深拷贝较复杂：需要手动实现clone()或使用序列化。
❌ 对引用类型字段需额外处理：浅拷贝可能导致意外的共享对象问题。

---

5. 原型模式的应用场景

1. 对象初始化成本高（如数据库查询、网络请求）。
2. 需要动态配置对象（如游戏中的角色克隆）。
3. 避免重复创建相似对象（如缓存对象池）。
4. 框架和库的默认实现（如Java中的ArrayList.clone()）。

---

6. 总结

特性	浅拷贝	深拷贝
复制内容	基本类型 + 引用地址	基本类型 + 引用对象
引用对象是否独立	否（共享）	是（独立）
实现方式	super.clone()	手动clone() 或序列化
适用场景	引用对象不可变或无需独立	引用对象需独立修改

原型模式的核心是clone()方法，适用于避免重复创建对象的场景。
浅拷贝简单但可能共享对象，深拷贝更安全但实现较复杂。
序列化方式适合复杂对象，但性能较低