首先看看简历代码初步实现的代码：
<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;"><SPAN style="FONT-SIZE: 18px">//简历类
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.sex = sex;
this.age = age;
}
//设置工作经历
public void SetWorkExperience(string timeArea, string company)
{
this.timeArea = timeArea;
this.company = company;
}
//显示
public void Display()
{
Console.WriteLine("{0}{1}{2}", name, sex, age);
Console.WriteLine("工作经历：{0}{1}", timeArea, company);
}
}</SPAN></span></span><span style="font-family:Microsoft YaHei;"><span style="font-size:18px;"><span style="font-size:18px;">下面看看客户端调用代码：</span></span></span><span style="font-family:Microsoft YaHei;"><span style="font-size:18px;"><SPAN style="FONT-SIZE: 18px"> class Program
{
static void Main(string[] args)
{
Resume a = new Resume("大鸟");
a.SetPersonalInfo("男", "29");
a.SetWorkExperience("1998-2000","XX公司");
Resume b = (Resume)a.Clone();
b.SetWorkExperience("1998-2000", "XX公司");
Resume c = (Resume)a.Clone();
c.SetPersonalInfo("男", "24");
c.SetWorkExperience("1998-2000","XX公司");
a.Display();
b.Display();
c.Display();
Console.Read();
}
}</SPAN>
}
}
</span></span>运行结果内存图，如下:
不足：上面三份简历需要实例化三次，客户端代码多，当简历达到20份甚至上百份时，可想而知，客户端就不能看，内容也是被大量的消耗掉。
下面是改进客户端代码后的结果，改进后的客户端代码如下：
<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;"><SPAN style="FONT-SIZE: 18px"> class Program
{
static void Main(string[] args)
{
Resume a = new Resume("大鸟");
a.SetPersonalInfo("男", "29");
a.SetWorkExperience("1998-2000","XX公司");
Resume b = a;
Resume c = a;
a.Display();
b.Display();
c.Display();
Console.Read();
}
}</SPAN> </span></span>
运行结果内存图，如下:
优点；上面的Resume b=a；其实就是传引用，而不是传值，这样做就如同在b纸张上写者简历在a处一样，没有实际的内容的，这样做大量的节省了内存的空间，但是上面适用于字段的值完全相同的情况，当a，b，c要求某些字段有区别时，传引用就不能达到要求了。
提到这里，我们就要提到一个设计模式了------原型设计模式
这里对原型模式进行一下简单的介绍：
原型模式：用原型实例创建对象的种类，并且通过拷贝这些原型创建新的对象。
基本原型模式的实现代码
<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;"><SPAN style="FONT-SIZE: 18px">namespace 原型模式
{
class Program
{
static void Main(string[] args)
{
ConcretePrototype1 p1 = new ConcretePrototype1("I");
//克隆类ConcretePrototype1的对象p1就能得到新的实例c1
ConcretePrototype1 c1 = (ConcretePrototype1)p1.Clone();
Console.WriteLine("Cloned:{0}", c1.Id);
Console.Read();
}
}
//原型类
abstract class Prototype
{
private string id;
public Prototype(string id)
{
this.id = id;
}
public string Id
{
get { return id; }
}
//在抽象类中声明一个克隆的方法
public abstract Prototype Clone();
}
//具体原型类
class ConcretePrototype1 : Prototype
{
public ConcretePrototype1(string id)
: base(id)
{ }
public override Prototype Clone()
{
//创建当前对象的浅副表本
return (Prototype)this.MemberwiseClone();
}
}
}</SPAN>
</span></span>
MemberwiseClone()方法是创建一个新对象，然后将当前对象的非静态字段复制到该新对象。如果字段是值类型的，则对该字段执行逐位复制。如果字段是引用类型，则复制引用但不复制引用的对象；因此，原始对象及其副本引用同一对象。
对上面的简历应用原型模式之后，代码如下：
例如，复制一份简历，简历的原型实现
实现如下：
<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;">//简历类
class Resume:ICloneable
{
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.sex = sex;
this.age = age;
}
//设置工作经历
public void SetWorkExperience(string timeArea, string company)
{
this.timeArea = timeArea;
this.company = company;
}
//显示
public void Display()
{
Console.WriteLine("{0}{1}{2}", name, sex, age);
//实现接口的方法，用来克隆对象
Console.WriteLine("工作经历：{0}{1}", timeArea, company);
}
public object Clone()
{
return (Object)this.MemberwiseClone();
}
}
</span></span>
客户端实现代码如下：
<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;"><SPAN style="FONT-SIZE: 18px"> class Program
{
static void Main(string[] args)
{
Resume a = new Resume("大鸟");
a.SetPersonalInfo("男", "29");
a.SetWorkExperience("1998-2000","XX公司");
Resume b = (Resume)a.Clone();
b.SetWorkExperience("1998-2006", "YY企业");
Resume c = (Resume)a.Clone();
c.SetPersonalInfo("男", "24");
a.Display();
b.Display();
c.Display();
Console.Read();
}
}</SPAN>
</span></span>运行结果内存图如下：
好处：客户端代码变得清晰了，当你想要修改某份简历，直接对这份简历修改就可以，不会影响到其他简历，相同的部分就不用再写代码了，只修改不同之处就可以。性能也提高了，因为每new一次，都需要执行一次构造函数，如果构造函数的执行时间很长，那么多次执行这个初始化操作就实在太低效率了。
一般在初始化的信息不发生变化的情况下，克隆是最好的办法。这既隐藏了对象创建的细节，又对性能是大大的提升。
上面使用了MemberwiseClone()方法，其实就是应用了浅复制，但是上面的成员变量没有引用类型的，所以，看不出深复制于浅复制的区别。
下面以引用类型为例，讲解深复制与浅复制的区别。
将timeArea和company这两个成员变量从Resume这里类里抽出来，然后放到WorkExperienc这个类里，但是简历里又要包含某个人的工作经验，所以，就把timeArea和company这两个成员变量放在Resume里定义，成为引用类型的成员变量。
浅复制： 被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。也就是说，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
我们先来看一个例子，简历复制。
结构图
代码实现
<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;">工作经历类
//工作经历
class WorkExperience
{
private string workDate;
public string WorkDate
{
get { return workDate; }
set { workDate = value; }
}
private string company;
public string Company
{
get { return company; }
set { company = value; }
}
}</span></span>
<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;">简历类
//简历类
class Resume:ICloneable
{
private string name;
private string sex;
private string age;
//引用"工作经历"对象
private WorkExperience work;
public Resume(string name)
{
this.name = name;
//在"简历"类实例化时同时实例化"工作经历"
work = new WorkExperience();
}
//设置个人信息
public void SetPersonalInfo(string sex, string age)
{
this.sex = sex;
this.age = age;
}
//设置工作经历
public void SetWorkExperience(string workDate, string company)
{
work.WorkDate = workDate;
//调用此方法时，给对象的两个属性赋值
work.Company = company;
}
//显示
public void Display()
{
Console.WriteLine("{0}{1}{2}", name, sex, age);
Console.WriteLine("工作经历：{0}{1}", work.WorkDate , work.Company);
}
public object Clone()
{
return (Object)this.MemberwiseClone();
}
}</span></span>客户端调用代码
<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;"> class Program
{
static void Main(string[] args)
{
Resume a = new Resume("大鸟");
a.SetPersonalInfo("男", "29");
a.SetWorkExperience("1998-2000","XX公司");
Resume b = (Resume)a.Clone();
b.SetWorkExperience("1998-2006", "YY企业");
Resume c = (Resume)a.Clone();
c.SetPersonalInfo("男", "24");
c.SetWorkExperience("1998-2003","ZZ企业");
//b和c都克隆于a,但当它们都设置了“工作经历”时，我们希望的结果是三个的显示不一样
a.Display();
b.Display();
c.Display();
Console.Read();
}
}</span></span>运行内存图如下：
上面就是浅复制，被复制对象的所有变量都含有跟原来的对象相同的值，而所有的其他对象的引用都仍然指向原来的对象。
比如上面的例子：work是引用类型的变量，在内存中work指向了内存中对象workExperience的一块区域，当a.clone（）时，a对应的内存区域会被复制，但是其里面包含的work对应的一块区域不会被复制，只是复制work的指向（引用）。
深复制
被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过得新对象，而不再是原有的那些被引用的对象。也就是说把要复制的对象所引用的对象都复制了一遍。
还是以简历复制为例。
结构图
代码实现
简历类
<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;">//简历
class Resume:ICloneable
{
private string name;
private string sex;
private string age;
private WorkExperience work;
public Resume(string name)
{
this.name = name;
work = new WorkExperience();
}
//提供Clone方法调用的私有构造函数，以便克隆“工作经历”的数据
//与浅复制的不同之处
private Resume(WorkExperience work)
{
this.work = (WorkExperience)work.Clone();
}
//设置个人信息
public void SetPersonalInfo(string sex, string age)
{
this.sex = sex;
this.age = age;
}
//设置工作经历
public void SetWorkExperience(string workDate, string company)
{
work.WorkDate = workDate;
work.Company = company;
}
//显示
public void Display()
{
Console.WriteLine("{0}{1}{2}", name, sex, age);
Console.WriteLine("工作经历：{0}{1}", work.WorkDate , work.Company);
}
//克隆
public object Clone()
{
//调用私有的构造方法，让“工作经历”克隆完成，
//然后再给简历对象的相关字段赋值，最终返回一个深复制的简历对象
Resume obj = new Resume(this.work);
obj.name = this.name;
obj.sex = this.sex;
obj.age = this.age;
return obj;
}
}</span></span>工作经历类
<span style="font-family:Microsoft YaHei;"><span style="font-size:18px;">
//工作经历
//工作经历类实现接口
class WorkExperience:ICloneable
{
private string workDate;
public string WorkDate
{
get { return workDate; }
set { workDate = value; }
}
private string company;
public string Company
{
get { return company; }
set { company = value; }
}
public Object Clone()
{
//工作经历类实现克隆方法
return (Object)this.MemberwiseClone();
}
}</span></span>运行内存图如下：
这样，最终结果实现了深复制，将WorkExperience实现接口ICloneable，因此work也可以执行Clone（）方法，通过将类Resume的构造函数声明为private类型，并且类里面重写Clone（）方法，实现了克隆简历的同时，也克隆了WorkExperience。
总结
一.需要具备以下两个条件：
实现Cloneable接口。在java语言有一个Cloneable接口，它的作用只有一个，就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java虚拟机中，只有实现了这个接口的类才可以被拷贝，否则在运行时会抛出CloneNotSupportedException异常。
重写Object类中的clone方法。Java中，所有类的父类都是Object类，Object类中有一个clone方法，作用是返回对象的一个拷贝，但是其作用域protected类型的，一般的类无法调用，因此，Prototype类需要将clone方法的作用域修改为public类型。
原型模式是一种比较简单的模式，也非常容易理解，实现一个接口，重写一个方法即完成了原型模式。在实际应用中，原型模式很少单独出现。经常与其他模式混用，他的原型类Prototype也常用抽象类来替代。
二.原型模式的优点及适用场景
使用原型模式创建对象比直接new一个对象在性能上要好的多，因为Object类的clone方法是一个本地方法，它直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显。
使用原型模式的另一个好处是简化对象的创建，使得创建对象就像我们在编辑文档时的复制粘贴一样简单。
因为以上优点，所以在需要重复地创建相似对象时可以考虑使用原型模式。比如需要在一个循环体内创建对象，假如对象创建过程比较复杂或者循环次数很多的话，使用原型模式不但可以简化创建过程，而且可以使系统的整体性能提高很多。
三.原型模式的注意事项
使用原型模式复制对象不会调用类的构造方法。因为对象的复制是通过调用Object类的clone方法来完成的，它直接在内存中复制数据，因此不会调用到类的构造方法。不但构造方法中的代码不会执行，甚至连访问权限都对原型模式无效。还记得单例模式吗？单例模式中，只要将构造方法的访问权限设置为private型，就可以实现单例。但是clone方法直接无视构造方法的权限，所以，单例模式与原型模式是冲突的，在使用时要特别注意。
深拷贝与浅拷贝。Object类的clone方法只会拷贝对象中的基本的数据类型，对于数组、容器对象、引用对象等都不会拷贝，这就是浅拷贝。如果要实现深拷贝，必须将原型模式中的数组、容器对象、引用对象等另行拷贝。
扫一扫
1010
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
