全网最简单的Java设计模式【九】原型模式深入解析-三、原型模式的实现方式

时间：2024-10-28 20:21:33

在 Java 中，原型模式可以通过两种方式实现：浅克隆（Shallow Clone）和深克隆（Deep Clone）。

（一）浅克隆实现

1. 假设我们有一个包含 基本数据类型 和 引用类型的类：

package com.jsglxx.design.prototype;

import java.util.List;

class Person implements Cloneable {
    private int age;
    private List<String> hobbies;

    public Person(int age, List<String> hobbies) {
        this.age = age;
        this.hobbies = hobbies;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

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

2. 使用示例：

package com.jsglxx.design.prototype;

import java.util.ArrayList;
import java.util.List;

public class ShallowCloneExample {
    public static void main(String[] args) {
        try {
            List<String> hobbies = new ArrayList<>();
            hobbies.add("Reading");
            Person original = new Person(30, hobbies);
            Person clone = (Person) original.clone();

            System.out.println("Original: Age = " + original.getAge() + ", Hobbies = " + original.getHobbies());
            System.out.println("Clone: Age = " + clone.getAge() + ", Hobbies = " + clone.getHobbies());

            // 修改原始对象的引用类型字段内容
            original.getHobbies().add("Drawing");
            original.setAge(35);

            System.out.println("After modification:");
            System.out.println("Original: Age = " + original.getAge() + ", Hobbies = " + original.getHobbies());
            System.out.println("Clone: Age = " + clone.getAge() + ", Hobbies = " + clone.getHobbies());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

3. 输出结果：

Original: Age = 30, Hobbies = [Reading]
Clone: Age = 30, Hobbies = [Reading]
After modification:
Original: Age = 35, Hobbies = [Reading, Drawing]
Clone: Age = 30, Hobbies = [Reading, Drawing]

在这个浅克隆示例中：

  • 首先创建了一个原始对象 original，其中包含一个基本数据类型 age 和一个引用类型 hobbies 列表。当通过 super.clone() 进行浅克隆创建 clone 对象时，基本数据类型 age 被按值复制，所以原始对象和克隆对象的 age 是独立的。
  • 然而，对于引用类型 hobbies 列表，浅克隆只是复制了引用，这意味着原始对象和克隆对象中的 hobbies 指向同一个列表对象。
  • 当修改原始对象的 hobbies 列表内容（添加 “Drawing”）以及修改 age 为 35 时，由于克隆对象的 hobbies 引用与原始对象相同，所以克隆对象的 hobbies 列表也会显示添加后的内容。而克隆对象的 age 虽然在克隆时与原始对象相同，但由于基本数据类型是按值复制，所以不会随原始对象的修改而改变。

（二）深克隆示例

1. 为了实现深克隆，可以使用序列化的方式：

package com.jsglxx.design.prototype.deep;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.List;

class Person implements Serializable {

	private static final long serialVersionUID = 1L;
	
	private int age;
    private List<String> hobbies;

    public Person(int age, List<String> hobbies) {
        this.age = age;
        this.hobbies = hobbies;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public Person deepClone() {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(this);

            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            return (Person) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }
}

2. 使用示例：

package com.jsglxx.design.prototype.deep;

import java.util.ArrayList;
import java.util.List;

public class DeepCloneExample {
    public static void main(String[] args) {
        try {
            List<String> hobbies = new ArrayList<>();
            hobbies.add("Reading");
            Person original = new Person(30, hobbies);
            Person clone = original.deepClone();

            System.out.println("Original: Age = " + original.getAge() + ", Hobbies = " + original.getHobbies());
            System.out.println("Clone: Age = " + clone.getAge() + ", Hobbies = " + clone.getHobbies());

            // 修改原始对象的引用类型字段内容
            original.getHobbies().add("Drawing");
            original.setAge(35);

            System.out.println("After modification:");
            System.out.println("Original: Age = " + original.getAge() + ", Hobbies = " + original.getHobbies());
            System.out.println("Clone: Age = " + clone.getAge() + ", Hobbies = " + clone.getHobbies());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这个深克隆示例中，

  1. 通过序列化的方式进行深克隆。首先将原始对象序列化为字节流，然后再从字节流中反序列化出一个新的对象作为克隆对象。
  2. 对于基本数据类型 age，其行为与浅克隆类似，被按值复制，所以原始对象和克隆对象的 age 是独立的。
  3. 对于引用类型 hobbies 列表，在深克隆过程中，实际上创建了一个新的列表对象，并将原始列表中的内容复制到新列表中。这意味着原始对象和克隆对象的 hobbies 列表是完全独立的两个对象。
  4. 当修改原始对象的 hobbies 列表内容（添加 “Drawing”）以及修改 age 为 35 时，由于克隆对象的 hobbies 列表是独立的新对象，所以不会受到原始对象修改的影响。而克隆对象的 age 也同样不会随原始对象的修改而改变。

相关文章