设计模式--原型模式

2023-04-09

字数统计: 1.2k字 | 阅读时长≈ 4分

原型模式：是一种创建型设计模式，它允许通过复制现有对象来创建新对象，而无需知道创建新对象的细节。原型模式的核心思想是将一个原型对象作为模板，通过复制来创建新的对象。原型模式常常用于需要创建大量相似对象的场景，可以大大提高程序的性能和效率。在原型模式中，原型对象通常是通过浅拷贝或深拷贝来复制的。浅拷贝只复制对象的基本属性，而不复制对象的引用类型属性，因此新对象和原对象会共享一些属性值。深拷贝则会完全复制对象及其所有引用类型属性，因此新对象和原对象完全独立。

原型模式优点：

简化对象的创建过程，通过复制一个已有实例可以提高新实例的创建效率，扩展性较好
简化创建结构，原型模式中产品的复制是通过封装在原型类中的克隆方法实现的，无须专门的工厂类来创建产品
可以使用深克隆的方式保存对象的状态，以便在需要的时候使用，可辅助实现撤销操作

原型模式缺点：

需要为每一个类配备一个克隆方法，而且该克隆方法位于一个类的内部，当对已有的类进行改造时，需要修改源代码，违背了开闭原则
在实现深克隆时需要编写较为复杂的代码，而且当对象之间存在多重的嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来可能会比较麻烦

适用场景：

创建新对象成本较大，新对象可以通过复制已有对象来获得，如果是相似对象，则可以对其成员变量稍作修改
系统要保存对象的状态，而对象的状态变化很小
需要避免使用分层次的工厂类来创建分层次的对象

深拷贝：(对象序列化和反序列化实现)

定义需要克隆的对象，该对象需要实现 Serializable 接口

public class Person implements Serializable {
    private String name;
    private int age;
    private Address address;

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

    // 省略 getter 和 setter 方法
}

定义需要克隆的对象中的引用类型对象，该对象也需要实现 Serializable 接口。

public class Address implements Serializable {
    private String city;
    private String street;

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

    // 省略 getter 和 setter 方法
}

定义一个工具类，实现对象的深克隆。

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class CloneUtils {
    @SuppressWarnings("unchecked")
    public static <T extends Serializable> T clone(T obj) {
        T cloneObj = null;
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(obj);

            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            cloneObj = (T) ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return cloneObj;
    }
}

在客户端中使用 CloneUtils 工具类进行对象的深克隆。

public class Client {
    public static void main(String[] args) {
        Address address = new Address("北京", "朝阳区");
        Person person1 = new Person("张三", 20, address);

        Person person2 = CloneUtils.clone(person1);

        System.out.println(person1 == person2); // false
        System.out.println(person1.getAddress() == person2.getAddress()); // false
    }
}

浅拷贝：(Java中的Object类提供的clone()方法)

Java中的Object类提供了一个clone()方法，允许对象创建一个新的副本。该方法返回一个新的对象，该对象与原始对象具有相同的状态和属性，是一个新的独立的对象，而不是原始对象的引用,但如果原对象中有其他对象属性，则复制后的对象引用原对象中的对象属性。(复制后的对象基本数据类型独立，引用类型的属性只是复制了引用地址)

要使用clone()方法，必须保证对象的类实现了Cloneable接口。如果对象的类没有实现Cloneable接口，调用clone()方法将会抛出CloneNotSupportedException异常。

class Person implements Cloneable {
    String name;
    int age;
    Address address;

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

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

class Address {
    String street;
    String city;
    String state;

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

public class CloneExample {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("123 Main St", "Anytown", "CA");
        Person person1 = new Person("John", 30, address);
        Person person2 = (Person)person1.clone();

        System.out.println(person1.address == person2.address); // true
    }
}

本文作者： zzr
本文链接： http://zzruei.github.io/2023/04daad143.html
版权声明： 本博客所有文章除特别声明外，均采用 Apache License 2.0 许可协议。转载请注明出处！