什么是原型模式
原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
原型模式就是从一个对象在创建另外一个可定制的对象，而不需要知道任何创建细节。
clone()方法的作用：创建当前对象的浅拷贝。方式是创建一个新对象，然后将当前对象的非静态字段复制到该新对象。如果字段是值类型的，则对该字段字段逐位复制。如果字段是引用类型，则复制引用但不复制引用的对象，因此，原始对象及其副本引用同一对象。而String是一种拥有值类型特点的特殊引用类型。
类图
demo代码（实际情况下不这么写，原因见下面）
Prototype
public abstract class Prototype {
public abstract Prototype clone();
}
ConcretePrototype1
public class ConcretePrototype1 extends Prototype {
private String id;
public ConcretePrototype1(String id){
this.id=id;
}
@Override
public Prototype clone() {
return this.clone();
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
Main
public class Main {
public static void main(String[] args) {
//这只是一个例子，并不能运行成功！
ConcretePrototype1 c1=new ConcretePrototype1("1");
ConcretePrototype1 c2=(ConcretePrototype1)c1.clone();
System.out.println(c1.getId());
System.out.println(c2.getId());
c2.setId("2");
System.out.println(c1.getId());
System.out.println(c2.getId());
}
}
简历复印
对于java而言，原型抽象类Prototype是用不着的，因为java提供了Cloneable接口，里面只有一个clone()方法，这样就只要实现这个接口，就能完成原型模式了。
类图
代码：
WorkExperience
public class WorkExperience implements Cloneable {
private String workTime;
private String company;
@Override
public Object clone(){
Object obj=null;
try {
obj=super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return obj;
}
public String getWorkTime() {
return workTime;
}
public void setWorkTime(String workTime) {
this.workTime = workTime;
}
public String getCompany() {
return company;
}
public void setCompany(String company) {
this.company = company;
}
}
浅拷贝代码：
Resume1
public class Resume1 implements Cloneable {
private String name;
private String sex;
private String age;
private WorkExperience workExperience;
public Resume1(String name) {
this.name = name;
this.workExperience = new WorkExperience();
}
private Resume1(WorkExperience workExperience) {
this.workExperience = (WorkExperience) workExperience.clone();
}
public void setPersonalInfo(String sex, String age) {
this.sex = sex;
this.age = age;
}
public void setWorkExperience(String workTime, String company) {
workExperience.setWorkTime(workTime);
workExperience.setCompany(company);
}
public void display() {
System.out.println(String.format("%s %s %s", name, sex, age));
System.out.println(String.format("工作经历：%s %s ", workExperience.getWorkTime(), workExperience.getCompany()));
}
//浅拷贝
@Override
public Object clone(){
Object obj=null;
try {
//姓名、年龄、性别 是 值类型的变量；而工作经历 是 引用类型的变量
obj=super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return obj;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public WorkExperience getWorkExperience() {
return workExperience;
}
public void setWorkExperience(WorkExperience workExperience) {
this.workExperience = workExperience;
}
}
Main1
public class Main1 {
public static void main(String[] args) throws Exception {
Resume1 a=new Resume1("大鸟");
a.setPersonalInfo("男","29");
a.setWorkExperience("1998-2000","xx公司");
Resume1 b=(Resume1) a.clone();
b.setWorkExperience("1998-2006","yy公司");
Resume1 c=(Resume1) a.clone();
c.setPersonalInfo("男","24");
a.display();
b.display();
c.display();
}
}
运行结果：
大鸟 男 29
工作经历：1998-2006 yy公司
大鸟 男 29
工作经历：1998-2006 yy公司
大鸟 男 24
工作经历：1998-2006 yy公司
深拷贝代码：
Resume2
public class Resume2 implements Cloneable {
private String name;
private String sex;
private String age;
private WorkExperience workExperience;
public Resume2(String name) {
this.name = name;
this.workExperience = new WorkExperience();
}
private Resume2(WorkExperience workExperience) {
this.workExperience = (WorkExperience) workExperience.clone();
}
public void setPersonalInfo(String sex, String age) {
this.sex = sex;
this.age = age;
}
public void setWorkExperience(String workTime, String company) {
workExperience.setWorkTime(workTime);
workExperience.setCompany(company);
}
public void display() {
System.out.println(String.format("%s %s %s", name, sex, age));
System.out.println(String.format("工作经历：%s %s ", workExperience.getWorkTime(), workExperience.getCompany()));
}
//深拷贝
@Override
public Object clone() {
/*
对工作经历进行了深拷贝
调用私有的构造方法，让工作经历克隆完成，然后给这个简历对象的相关字段赋值，最终返回一个深复制的简历对象。
*/
Resume2 obj = new Resume2(this.workExperience);
obj.setName(this.name);
obj.setAge(this.age);
obj.setSex(this.sex);
return obj;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public WorkExperience getWorkExperience() {
return workExperience;
}
public void setWorkExperience(WorkExperience workExperience) {
this.workExperience = workExperience;
}
}
Main2和Main1代码一样：
public class Main2 {
public static void main(String[] args) throws Exception {
Resume2 a=new Resume2("大鸟");
a.setPersonalInfo("男","29");
a.setWorkExperience("1998-2000","xx公司");
Resume2 b=(Resume2) a.clone();
b.setWorkExperience("1998-2006","yy公司");
Resume2 c=(Resume2) a.clone();
c.setPersonalInfo("男","24");
a.display();
b.display();
c.display();
}
}
运行结果：
大鸟 男 29
工作经历：1998-2000 xx公司
大鸟 男 29
工作经历：1998-2006 yy公司
大鸟 男 24
工作经历：1998-2000 xx公司
优点：
提高性能：每new一次，都要执行至此构造函数，如果构造函数的执行时间很长，那么多次的执行这个初始化操作就实在是太低效了。一般初始化的信息不发生变化的情况下，克隆是最好的办法。这个既隐藏了对象创建的细节，又大大的提高性能。原始模式等于是不用重新初始化对象，而是动态地获得对象运行时的状态。
浅拷贝与深拷贝：
浅拷贝：方式是创建一个新对象，然后将当前对象的非静态字段复制到该新对象。如果字段是值类型的，则对该字段字段逐位复制。如果字段是引用类型，则复制引用但不复制引用的对象，因此，原始对象及其副本引用同一对象。而String是一种拥有值类型特点的特殊引用类型。（String字符串，则拷贝其地址引用。但是在修改时，它会从字符串池中重新生成一个新的字符串，原有字符串对象保持不变）
深拷贝：把要复制的对象的所引用的对象都复制一遍。把引用对象的变量指向复制过的新对象，而不是原有的被引用的对象。
利用序列化实现对象的拷贝
如何利用序列化来完成对象的拷贝呢？在内存中通过字节流的拷贝是比较容易实现对象拷贝的。把母对象写入到一个字节流中，再从字节流中将其读出来，这样就可以创建一个新的对象了，并且该新对象与母对象之间并不存在引用共享的问题，真正实现对象的深拷贝。原型类必须要实现Serializable接口。
4093
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
