概述
什么是原型模式
原型模式是一种创建型设计模式，它允许通过复制现有对象来创建新对象，而无需依赖显式的实例化过程。使用原型模式，我们可以在运行时动态地创建对象，并且能够轻松地生成对象的副本。
浅拷贝和深拷贝
在原型模式中，复制对象的方式通常可以分为浅拷贝和深拷贝两种。
- 浅拷贝：浅拷贝创建一个新对象，该对象与原始对象共享一些属性。这意味着新对象中的引用类型属性仍然引用原始对象中相同的对象，对引用类型属性的更改会影响到原始对象和所有浅拷贝的对象。
- 深拷贝：深拷贝创建一个新对象，该对象与原始对象完全独立。这意味着新对象中的引用类型属性指向新的对象，对引用类型属性的更改不会影响原始对象或其他深拷贝的对象。
在选择浅拷贝还是深拷贝时，需要根据具体的需求和对象结构来决定。
类图
原型中的主要角色
- 原型（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; } //客户端不变 }
实现结果
这样就达到了预期的效果。
原型模式的优点
- 动态创建对象：原型模式允许在运行时动态地创建对象，而无需显式的实例化过程。这使得我们能够根据需要创建对象的副本，而不必依赖固定的类层次结构。
- 简化对象创建过程：通过复制现有对象，我们可以更轻松地创建新对象。这比手动设置对象的初始状态要简单得多，尤其当对象的创建过程非常复杂时。
- 减少资源消耗：与实例化相比，原型模式的对象复制过程通常更高效。它避免了执行复杂的初始化逻辑和与构造函数相关的资源消耗。
原型模式的应用场景
- 当系统中的对象数量很大，但创建和初始化对象的过程很复杂时，原型模式可以显著简化对象的创建过程。
- 当需要创建对象的副本，而无需暴露对象的创建细节时，可以使用原型模式。
- 当需要避免与对象的产生和初始化过程相关的资源消耗时，原型模式是一个很好的选择。
原型模式的创新
原型模式在对象创建的过程中，通过复制现有对象来创建新对象，从而避免了显式的实例化过程。这种动态创建对象的方式带来了一些创新和优势：
简化对象创建：原型模式使得创建新对象变得简单直观，通过在现有对象的基础上进行复制，避免了繁琐的初始化过程和构造函数的调用。相比传统的实例化方式，原型模式提供了更加简洁、灵活的对象创建方式。
动态性和扩展性：原型模式允许在运行时动态地创建对象的副本。这意味着可以根据需要创建不同类型的对象，并且可以随时修改或增加现有对象的属性和行为。这种动态性和扩展性使得原型模式在设计阶段更具灵活性和适应性。
减少资源消耗：相对于传统的实例化方式，原型模式的对象复制过程通常更高效。它避免了执行复杂的初始化逻辑和与构造函数相关的资源消耗。通过原型模式，可以复用已有对象的状态，减少了重复创建对象的开销。
保护对象创建细节：原型模式将对象的创建细节封装在原型对象内部，对客户端隐藏了具体的创建过程。这样，客户端无需了解对象的具体创建逻辑，仅需通过原型对象进行复制即可获得新对象。这种封装性保护了对象的创建细节，提高了代码的可维护性和安全性。
总结
原型模式允许通过复制现有对象来创建新对象，而无需显式的实例化过程。它提供了一种动态创建对象的方式，并且可以简化对象的创建过程。通过浅拷贝和深拷贝的选择，可以控制对象副本的共享程度。
