设计模式之原型模式--超越实例化的魔法，从复制到创造的无限可能-阿里云开发者社区

概述

什么是原型模式

原型模式是一种创建型设计模式，它允许通过复制现有对象来创建新对象，而无需依赖显式的实例化过程。使用原型模式，我们可以在运行时动态地创建对象，并且能够轻松地生成对象的副本。

浅拷贝和深拷贝

在原型模式中，复制对象的方式通常可以分为浅拷贝和深拷贝两种。

浅拷贝：浅拷贝创建一个新对象，该对象与原始对象共享一些属性。这意味着新对象中的引用类型属性仍然引用原始对象中相同的对象，对引用类型属性的更改会影响到原始对象和所有浅拷贝的对象。
深拷贝：深拷贝创建一个新对象，该对象与原始对象完全独立。这意味着新对象中的引用类型属性指向新的对象，对引用类型属性的更改不会影响原始对象或其他深拷贝的对象。
在选择浅拷贝还是深拷贝时，需要根据具体的需求和对象结构来决定。

类图

原型中的主要角色

原型（Prototype）：原型是一个抽象类或接口，定义了可以复制自己的方法 clone()。具体的原型对象需要实现这个方法来进行对象的复制。
具体原型（Concrete Prototype）：具体原型是实现了原型接口的具体类。它通过实现 clone() 方法来复制自身，并生成一个新的对象，保持与原始对象相似的状态。
客户端（Client）：客户端是使用原型对象的地方。它通过请求原型对象来创建新的对象实例，而无需直接调用构造函数进行实例化。

工作流程

在原型模式中，客户端通过以下步骤使用原型对象：

创建一个原型对象的实例。通过调用原型对象的 clone() 方法复制自己，从而得到一个新的对象。
对新对象进行进一步的定制和修改，使其符合需求。

代码衍化过程

业务需求：打印简历

初版

业务：打印个人简历，包括个人信息，工作经历

//简历类
public class Resume {
    private String name;
    private String sex;
    private String age;
    private String timeArea;
    private String company;
    public Resume(String name){
        this.name=name;
    }
    //设置个人信息
    public void setPersonalInfo(String sex,String age){
        this.age=age;
        this.sex=sex;
    }
    //设置工作经历
    public void setWorkExperience(String timeArea,String company){
        this.timeArea=timeArea;
        this.company=company;
    }
    //展示简历
    public void display(){
        System.out.println(this.name+" " +this.sex+" "+this.age);
        System.out.println("工作经历"+this.timeArea+" "+this.company);
    }
//客户端
public class Client {
    public static void main(String[] args) {
        Resume resume1=new Resume("张三");
        resume1.setPersonalInfo("男","22");
        resume1.setWorkExperience("2020-2023","XX公司");
        resume1.display();
        Resume resume2=new Resume("张三");
        resume2.setPersonalInfo("男","22");
        resume2.setWorkExperience("2020-2023","XX公司");
        resume2.display();
        Resume resume3=new Resume("张三");
        resume3.setPersonalInfo("男","22");
        resume3.setWorkExperience("2020-2023","XX公司");
        resume3.display();
    }
}
}

一个简历类，在客户端中通过实例化简历类传入相同的信息来实现打印多份简历

问题：客户端麻烦，打印几份简历客户端就是要实例化几次，而且调整简历内容，每个都要调整。

引入原型模式

原型模式基本代码

//原型
abstract class Prototype implements Cloneable{
    private String id;
    public Prototype(String id){
        this.id=id;
    }
    public String getId() {
        return id;
    }
   //原型的关键方法
    public Object clone(){
        Object object=null;
        try {
            object=super.clone();
        } catch (CloneNotSupportedException e) {
            System.err.println("clone异常");
        }
        return object;
    }
}
//具体原型
public class ConcreteProtype extends Prototype{
    public ConcreteProtype(String id){
        super(id);
    }
}
//客户端
public class Client {
    public static void main(String[] args) {
        ConcreteProtype p1=new ConcreteProtype("编号123456");
        System.out.println("原型ID："+p1.getId());
        ConcreteProtype c1=(ConcreteProtype)p1.clone();
        System.out.println("克隆ID："+c1.getId());
    }
}

运行结果

这里不用实例化ConcreteProtype ，直接使用克隆对象，对于Java而言，Prototype 是用不上的，因为Java提供了Cloneable接口，其中唯一的方法clone(),使用时直接实现这个接口就可以完成原型模式了。

简历的原型实现

//简历类
public class Resume implements Cloneable{
    private String name;
    private String sex;
    private String age;
    private String timeArea;
    private String company;
    public Resume(String name){
        this.name=name;
    }
    //设置个人信息
    public void setPersonalInfo(String sex,String age){
        this.age=age;
        this.sex=sex;
    }
    //设置工作经历
    public void setWorkExperience(String timeArea,String company){
        this.timeArea=timeArea;
        this.company=company;
    }
    //展示简历
    public void display(){
        System.out.println(this.name+" " +this.sex+" "+this.age);
        System.out.println("工作经历"+this.timeArea+" "+this.company);
    }
    public Resume Clone(){
        Resume object=null;
        try {
            object=(Resume) super.clone();
        } catch (CloneNotSupportedException e) {
           System.err.println("clone异常");
        }
        return object;
    }
}
//客户端
public class Client {
    public static void main(String[] args) {
        Resume resume1=new Resume("大鸟");
        resume1.setPersonalInfo("男","23");
        resume1.setWorkExperience("2020-2023","Xx公司");
        Resume resume2=resume1.Clone();
        resume2.setWorkExperience("2022-2023","YY公司");
        Resume resume3=resume1.Clone();
        resume3.setPersonalInfo("男","24");
        resume1.display();
        resume2.display();
        resume3.display();
    }
}

在上面的代码中，Resume 类实现了 Cloneable 接口，表明该类可以被克隆。

Clone() 方法重写了 Object 类的 clone() 方法，通过调用 super.clone() 实现浅拷贝，并返回一个克隆后的新对象。

客户端的代码就简单很多，要是想改某份简历，只需要对这份简历做一定的修改就可以了，不会影响到其他简历，而且提高了效率，不用重新初始化对象，而是动态地获得对象运行时的状态。一般在初始化的信息不发生变化的情况下，克隆是最好的办法。这既隐藏了对象创建的细节，又对性能是大大的提高。

浅复制

//工作经历类
public class WorkExperience {
    //工作时间范围
    private String timeArea;
    public String getTimeArea() {
        return timeArea;
    }
    public void setTimeArea(String timeArea) {
        this.timeArea = timeArea;
    }
    //所在公司
    private String company;
    public String getCompany() {
        return company;
    }
    public void setCompany(String company) {
        this.company = company;
    }
}
//简历类
public class Resume implements Cloneable {
    private String name;
    private String sex;
    private String age;
    private WorkExperience work;//声明一个工作经历对象
    public Resume(String name){
        this.name=name;
        this.work=new WorkExperience();//实例化一个工作 经历对象
    }
    public void setPersonalInfo(String sex,String age){
        this.age=age;
        this.sex=sex;
    }
    //设置工作经历
    public void setWorkExperience(String timeArea,String company){
        this.work.setTimeArea(timeArea);
        this.work.setCompany(company);;
    }
    //展示简历
    public void display(){
        System.out.println(this.name+" " +this.sex+" "+this.age);
        System.out.println("工作经历"+this.work.getTimeArea()+" " +this.work.getCompany());
    }
    public Resume clone(){
        Resume object=null;
        try {
            object=(Resume) super.clone();
        } catch (CloneNotSupportedException e) {
            System.err.println("clone异常");
        }
        return object;
    }
}
//客户端
public class Client {
    public static void main(String[] args) {
        Resume resume1=new Resume("张三");
        resume1.setPersonalInfo("男","30");
        resume1.setWorkExperience("2000-2010","Xx公司");
        Resume resume2=resume1.clone();
        resume2.setWorkExperience("2001-2011","YY集团");
        Resume resume3=resume1.clone();
        resume3.setPersonalInfo("女","35");
        resume3.setWorkExperience("2020-2023","ZZ公司");
        resume1.display();
        resume2.display();
        resume3.display();
    }
}

运行结果

为什么会出现这种情况，引用对象好像覆盖了前面的对象，这个需要了解一下clone()方法。

Object 类的 clone() 方法是一个受保护的本地方法。代码中的super.clone() 方法内部的实现通过调用本地方法来完成对象的浅拷贝。

实际上，Object 类的 clone() 方法的实现有一定的约束条件：

首先，clone() 方法只能被实现了 Cloneable 接口的类调用。如果没有实现 Cloneable 接口，调用 clone() 方法将抛出 CloneNotSupportedException 异常。

其次，clone() 方法返回的是当前对象的浅拷贝，即新对象和原始对象共享相同的数据引用。

这意味着，只有基本类型的字段会被复制，而对于非基本类型（如数组、集合、对象等），只是复制了引用而不是创建新的对象。

由于浅拷贝只是复制了引用而不是创建新的对象，所以在使用 super.clone() 方法时需要小心处理可变对象和引用类型的字段。如果希望进行深拷贝，需要在 clone() 方法中显式地处理这些字段，以确保每个对象都是独立的副本。

深拷贝

//工作经验类也实现cloneable接口
public class WorkExperience implements Cloneable{
    private String timeArea;
    public String getTimeArea() {
        return timeArea;
    }
    public void setTimeArea(String timeArea) {
        this.timeArea = timeArea;
    }
    //所在公司
    private String company;
    public String getCompany() {
        return company;
    }
    public void setCompany(String company) {
        this.company = company;
    }
    public WorkExperience clone(){
       WorkExperience object=null;
        try {
            object=(WorkExperience) super.clone();
        } catch (CloneNotSupportedException e) {
            System.err.println("clone异常");
        }
        return object;
    }
}
//简历类
public class Resume implements Cloneable{
    private String name;
    private String sex;
    private String age;
    private WorkExperience work;//声明一个工作经历对象
    public Resume(String name){
        this.name=name;
        this.work=new WorkExperience();//实例化一个工作 经历对象
    }
    public void setPersonalInfo(String sex,String age){
        this.age=age;
        this.sex=sex;
    }
    //设置工作经历
    public void setWorkExperience(String timeArea,String company){
        this.work.setTimeArea(timeArea);
        this.work.setCompany(company);;
    }
    //展示简历
    public void display(){
        System.out.println(this.name+" " +this.sex+" "+this.age);
        System.out.println("工作经历"+this.work.getTimeArea()+" " +this.work.getCompany());
    }
    public Resume clone(){
     Resume object=null;
        try {
            object=(Resume) super.clone();
            this.work= this.work.clone();//对克隆对象里的引用也进行克隆，就达到了深复制的作用
        } catch (CloneNotSupportedException e) {
            System.err.println("clone异常");
        }
        return object;
    }
//客户端不变
}

实现结果

这样就达到了预期的效果。

原型模式的优点

动态创建对象：原型模式允许在运行时动态地创建对象，而无需显式的实例化过程。这使得我们能够根据需要创建对象的副本，而不必依赖固定的类层次结构。
简化对象创建过程：通过复制现有对象，我们可以更轻松地创建新对象。这比手动设置对象的初始状态要简单得多，尤其当对象的创建过程非常复杂时。
减少资源消耗：与实例化相比，原型模式的对象复制过程通常更高效。它避免了执行复杂的初始化逻辑和与构造函数相关的资源消耗。

原型模式的应用场景

当系统中的对象数量很大，但创建和初始化对象的过程很复杂时，原型模式可以显著简化对象的创建过程。
当需要创建对象的副本，而无需暴露对象的创建细节时，可以使用原型模式。
当需要避免与对象的产生和初始化过程相关的资源消耗时，原型模式是一个很好的选择。

原型模式的创新

原型模式在对象创建的过程中，通过复制现有对象来创建新对象，从而避免了显式的实例化过程。这种动态创建对象的方式带来了一些创新和优势：

简化对象创建：原型模式使得创建新对象变得简单直观，通过在现有对象的基础上进行复制，避免了繁琐的初始化过程和构造函数的调用。相比传统的实例化方式，原型模式提供了更加简洁、灵活的对象创建方式。

动态性和扩展性：原型模式允许在运行时动态地创建对象的副本。这意味着可以根据需要创建不同类型的对象，并且可以随时修改或增加现有对象的属性和行为。这种动态性和扩展性使得原型模式在设计阶段更具灵活性和适应性。

减少资源消耗：相对于传统的实例化方式，原型模式的对象复制过程通常更高效。它避免了执行复杂的初始化逻辑和与构造函数相关的资源消耗。通过原型模式，可以复用已有对象的状态，减少了重复创建对象的开销。

保护对象创建细节：原型模式将对象的创建细节封装在原型对象内部，对客户端隐藏了具体的创建过程。这样，客户端无需了解对象的具体创建逻辑，仅需通过原型对象进行复制即可获得新对象。这种封装性保护了对象的创建细节，提高了代码的可维护性和安全性。

总结

原型模式允许通过复制现有对象来创建新对象，而无需显式的实例化过程。它提供了一种动态创建对象的方式，并且可以简化对象的创建过程。通过浅拷贝和深拷贝的选择，可以控制对象副本的共享程度。

设计模式之原型模式--超越实例化的魔法，从复制到创造的无限可能

概述

什么是原型模式

浅拷贝和深拷贝

类图

原型中的主要角色

工作流程

代码衍化过程

初版

原型模式基本代码

简历的原型实现

浅复制

深拷贝

原型模式的优点

原型模式的应用场景

原型模式的创新

总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景