这个星期参加了一个面试，面试中问到深浅拷贝的区别，然后我就简单了讲述了它们的之间的区别，然后面试官又继续问，如何实现一个深拷贝呢？当时只回答回答了一种方式，就是使用反射，然后面试官提示还可以通过反序列化和表达树的方式。然后又继续问，如果用反射来实现深拷贝的话，如何解决互相引用对象的问题呢？ 当时我给出的答案是说那就不用反射去实现呗，用反序列化实现呗，或者直接避免使两个对象互相引用呗。然后面试官说，如果一定用反射来写，你是怎么去解决这个问题呢？这时候我就愣住了。

　　这样也就有了这篇文章。今天就来深入解析下深浅拷贝的问题。

　　首先，讲到深浅拷贝，自然就有一个问题来了？什么是深拷贝，什么又是浅拷贝呢？下面就具体介绍下它们的定义。

　　深拷贝：指的是拷贝一个对象时，不仅仅把对象的引用进行复制，还把该对象引用的值也一起拷贝。这样进行深拷贝后的拷贝对象就和源对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。举个例子，一个人叫张三，然后使用克隆技术以张三来克隆另外一个人叫李四，这样张三和李四就是相互独立的，不管张三缺胳膊还是李四少腿了都不会影响另外一个人。在.NET领域，值对象就是典型的例子，如int, Double以及结构体和枚举等。具体例子如下所示：

intsource=123;//值类型赋值内部执行深拷贝intcopy=source;//对拷贝对象进行赋值不会改变源对象的值copy=234;//同样对源对象赋值也不会改变拷贝对象的值source=345;

　　浅拷贝：指的是拷贝一个对象时，仅仅拷贝对象的引用进行拷贝，但是拷贝对象和源对象还是引用同一份实体。此时，其中一个对象的改变都会影响到另一个对象。例如，一个人一开始叫张三，后来改名字为张老三了，可是他们还是同一个人，不管张三缺胳膊还是张老三少腿，都反应在同一个人身上。在.NET中引用类型就是一个例子。如类类型。具体例子如下所示：

publicclassPerson{publicstringName{get;set;}}classProgram{staticvoidMain(string[]args){PersonsourceP=newPerson(){Name="张三"};PersoncopyP=sourceP;//浅拷贝copyP.Name="张老三";//拷贝对象改变Name值//结果都是"张老三",因为实现的是浅拷贝，一个对象的改变都会影响到另一个对象Console.WriteLine("Person.Name:[SourceP:{0}][CopyP:{1}]",sourceP.Name,copyP.Name);Console.Read();}}三、深浅拷贝的几种实现方式

　　上面已经明白了深浅拷贝的定义，至于他们之间的区别也在定义中也有所体现。介绍完了它们的定义和区别之后，自然也就有了如何去实现它们呢？

　　对于，浅拷贝的实现方式很简单，.NET自身也提供了实现。我们知道，所有对象的父对象都是System.Object对象，这个父对象中有一个MemberwiseClone方法，该方法就可以用来实现浅拷贝，下面具体看看浅拷贝的实现方式，具体演示代码如下所示：

//继承ICloneable接口，重新其Clone方法classShallowCopyDemoClass:ICloneable{publicintintValue=1;publicstringstrValue="1";publicPersonEnumpEnum=PersonEnum.EnumA;publicPersonStructpStruct=newPersonStruct(){StructValue=1};publicPersonpClass=newPerson("1");publicint[]pIntArray=newint[]{1};publicstring[]pStringArray=newstring[]{"1"};#regionICloneable成员publicobjectClone(){returnthis.MemberwiseClone();}#endregion}classPerson{publicstringName;publicPerson(stringname){Name=name;}}publicenumPersonEnum{EnumA=0,EnumB=1}publicstructPersonStruct{publicintStructValue;}

　　上面类中重写了IConeable接口的Clone方法，其实现直接调用了Object的MemberwiseClone方法来完成浅拷贝，如果想实现深拷贝，也可以在Clone方法中实现深拷贝的逻辑。接下来就是对上面定义的类进行浅拷贝测试了，看看是否是实现的浅拷贝，具体演示代码如下所示：

classProgram{staticvoidMain(string[]args){ShallowCopyDemo();//List浅拷贝的演示ListShallowCopyDemo();}publicstaticvoidListShallowCopyDemo(){List<PersonA>personList=newList<PersonA>(){newPersonA(){Name="PersonA",Age=10,ClassA=newA(){TestProperty="AProperty"}},newPersonA(){Name="PersonA2",Age=20,ClassA=newA(){TestProperty="AProperty2"}}};//下面2种方式实现的都是浅拷贝List<PersonA>personsCopy=newList<PersonA>(personList);PersonA[]personCopy2=newPersonA[2];personList.CopyTo(personCopy2);　　　　　　　//由于实现的是浅拷贝，所以改变一个对象的值，其他2个对象的值都会发生改变，因为它们都是使用的同一份实体，即它们指向内存中同一个地址　personsCopy.First().ClassA.TestProperty="AProperty3";WriteLog(string.Format("personCopy2.First().ClassA.TestPropertyis{0}",personCopy2.First().ClassA.TestProperty));WriteLog(string.Format("personList.First().ClassA.TestPropertyis{0}",personList.First().ClassA.TestProperty));WriteLog(string.Format("personsCopy.First().ClassA.TestPropertyis{0}",personsCopy.First().ClassA.TestProperty));　　　　　　　Console.Read();　}publicstaticvoidShallowCopyDemo(){ShallowCopyDemoClassDemoA=newShallowCopyDemoClass();ShallowCopyDemoClassDemoB=DemoA.Clone()asShallowCopyDemoClass;DemoB.intValue=2;WriteLog(string.Format("int->[A:{0}][B:{1}]",DemoA.intValue,DemoB.intValue));DemoB.strValue="2";WriteLog(string.Format("string->[A:{0}][B:{1}]",DemoA.strValue,DemoB.strValue));DemoB.pEnum=PersonEnum.EnumB;WriteLog(string.Format("Enum->[A:{0}][B:{1}]",DemoA.pEnum,DemoB.pEnum));DemoB.pStruct.StructValue=2;WriteLog(string.Format("struct->[A:{0}][B:{1}]",DemoA.pStruct.StructValue,DemoB.pStruct.StructValue));DemoB.pIntArray[0]=2;WriteLog(string.Format("intArray->[A:{0}][B:{1}]",DemoA.pIntArray[0],DemoB.pIntArray[0]));DemoB.pStringArray[0]="2";WriteLog(string.Format("stringArray->[A:{0}][B:{1}]",DemoA.pStringArray[0],DemoB.pStringArray[0]));DemoB.pClass.Name="2";WriteLog(string.Format("Class->[A:{0}][B:{1}]",DemoA.pClass.Name,DemoB.pClass.Name));　　　　　　　Console.WriteLine();　　　　　　}privatestaticvoidWriteLog(stringmsg){Console.WriteLine(msg);}　　}}

　　上面代码的运行结果如下图所示：

　　从上面运行结果可以看出，.NET中值类型默认是深拷贝的，而对于引用类型，默认实现的是浅拷贝。所以对于类中引用类型的属性改变时，其另一个对象也会发生改变。

　　上面已经介绍了浅拷贝的实现方式，那深拷贝要如何实现呢？在前言部分已经介绍了，实现深拷贝的方式有：反射、反序列化和表达式树。在这里，我只介绍反射和反序列化的方式，对于表达式树的方式在网上也没有找到，当时面试官说是可以的，如果大家找到了表达式树的实现方式，麻烦还请留言告知下。下面我们首先来看看反射的实现方式吧：

//利用反射实现深拷贝publicstaticTDeepCopyWithReflection<T>(Tobj){Typetype=obj.GetType();//如果是字符串或值类型则直接返回if(objisstring||type.IsValueType)returnobj;if(type.IsArray){TypeelementType=Type.GetType(type.FullName.Replace("[]",string.Empty));vararray=objasArray;Arraycopied=Array.CreateInstance(elementType,array.Length);for(inti=0;i<array.Length;i++){copied.SetValue(DeepCopyWithReflection(array.GetValue(i)),i);}return(T)Convert.ChangeType(copied,obj.GetType());}objectretval=Activator.CreateInstance(obj.GetType());PropertyInfo[]properties=obj.GetType().GetProperties(BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Instance|BindingFlags.Static);foreach(varpropertyinproperties){varpropertyValue=property.GetValue(obj,null);if(propertyValue==null)continue;property.SetValue(retval,DeepCopyWithReflection(propertyValue),null);}return(T)retval;}

　　反序列化的实现方式，反序列化的方式也可以细分为3种，具体的实现如下所示：

//利用XML序列化和反序列化实现publicstaticTDeepCopyWithXmlSerializer<T>(Tobj){objectretval;using(MemoryStreamms=newMemoryStream()){XmlSerializerxml=newXmlSerializer(typeof(T));xml.Serialize(ms,obj);ms.Seek(0,SeekOrigin.Begin);retval=xml.Deserialize(ms);ms.Close();}return(T)retval;}//利用二进制序列化和反序列实现publicstaticTDeepCopyWithBinarySerialize<T>(Tobj){objectretval;using(MemoryStreamms=newMemoryStream()){BinaryFormatterbf=newBinaryFormatter();//序列化成流bf.Serialize(ms,obj);ms.Seek(0,SeekOrigin.Begin);//反序列化成对象retval=bf.Deserialize(ms);ms.Close();}return(T)retval;}//利用DataContractSerializer序列化和反序列化实现publicstaticTDeepCopy<T>(Tobj){objectretval;using(MemoryStreamms=newMemoryStream()){DataContractSerializerser=newDataContractSerializer(typeof(T));ser.WriteObject(ms,obj);ms.Seek(0,SeekOrigin.Begin);retval=ser.ReadObject(ms);ms.Close();}return(T)retval;}//表达式树实现//....四、使用反射进行深拷贝如何解决相互引用的问题

　　上面反射的实现方式，对于相互引用的对象会出现StackOverflower的错误，由于对象的相互引用，会导致方法循环调用。下面就是一个相互引用对象的例子：

[Serializable]publicclassDeepCopyDemoClass{publicstringName{get;set;}publicint[]pIntArray{get;set;}publicAddressAddress{get;set;}publicDemoEnumDemoEnum{get;set;}//DeepCopyDemoClass中引用了TestB对象，TestB类又引用了DeepCopyDemoClass对象，从而造成了相互引用publicTestBTestB{get;set;}publicoverridestringToString(){return"DeepCopyDemoClass";}}[Serializable]publicclassTestB{publicstringProperty1{get;set;}publicDeepCopyDemoClassDeepCopyClass{get;set;}publicoverridestringToString(){return"TestBClass";}}[Serializable]publicstructAddress{publicstringCity{get;set;}}publicenumDemoEnum{EnumA=0,EnumB=1}

　　在面试过程中，针对这个问题的解决方式我回答的是不知道，回来之后思考了之后，也就有了点思路。首先想到的是：能不能用一个字典来记录每个对象被反射的次数，仔细想想可行，于是开始实现，初步修复后的反射实现如下所示：

publicclassDeepCopyHelper{//用一个字典来存放每个对象的反射次数来避免反射代码的循环递归staticDictionary<Type,int>typereflectionCountDic=newDictionary<Type,int>();publicstaticTDeepCopyWithReflection_Second<T>(Tobj){Typetype=obj.GetType();//如果是字符串或值类型则直接返回if(objisstring||type.IsValueType)returnobj;if(type.IsArray){TypeelementType=Type.GetType(type.FullName.Replace("[]",string.Empty));vararray=objasArray;Arraycopied=Array.CreateInstance(elementType,array.Length);for(inti=0;i<array.Length;i++){copied.SetValue(DeepCopyWithReflection_Second(array.GetValue(i)),i);}return(T)Convert.ChangeType(copied,obj.GetType());}//对于类类型开始记录对象反射的次数intreflectionCount=Add(typereflectionCountDic,obj.GetType());if(reflectionCount>1)returnobj;//这里有错误objectretval=Activator.CreateInstance(obj.GetType());PropertyInfo[]properties=obj.GetType().GetProperties(BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Instance|BindingFlags.Static);foreach(varpropertyinproperties){varpropertyValue=property.GetValue(obj,null);if(propertyValue==null)continue;property.SetValue(retval,DeepCopyWithReflection_Second(propertyValue),null);}return(T)retval;}privatestaticintAdd(Dictionary<Type,int>dict,Typekey){if(key.Equals(typeof(String))||key.IsValueType)return0;if(!dict.ContainsKey(key)){dict.Add(key,1);returndict[key];}dict[key]+=1;returndict[key];}}

　　下面用代码来测试下上面的代码是否已经解决了循环递归的问题，具体的测试代码如下所示：

classProgram{staticvoidMain(string[]args){//ShallowCopyDemo();//ListShallowCopyDemo();DeepCopyDemo();DeepCopyDemo2();}privatestaticvoidWriteLog(stringmsg){Console.WriteLine(msg);}publicstaticvoidDeepCopyDemo(){DeepCopyDemoClassdeepCopyClassA=newDeepCopyDemoClass();deepCopyClassA.Name="DeepCopyClassDemo";deepCopyClassA.pIntArray=newint[]{1};deepCopyClassA.DemoEnum=DemoEnum.EnumA;deepCopyClassA.Address=newAddress(){City="Shanghai"};deepCopyClassA.TestB=newTestB(){Property1="TestProperty",DeepCopyClass=deepCopyClassA};//使用反序列化来实现深拷贝DeepCopyDemoClassdeepCopyClassB=DeepCopyHelper.DeepCopyWithBinarySerialize<DeepCopyDemoClass>(deepCopyClassA);deepCopyClassB.Name="DeepCopyClassDemoB";WriteLog(string.Format("Name->[A:{0}][B:{1}]",deepCopyClassA.Name,deepCopyClassB.Name));deepCopyClassB.pIntArray[0]=2;WriteLog(string.Format("intArray->[A:{0}][B:{1}]",deepCopyClassA.pIntArray[0],deepCopyClassB.pIntArray[0]));deepCopyClassB.Address=newAddress(){City="Beijing"};WriteLog(string.Format("Addressstruct->[A:{0}][B:{1}]",deepCopyClassA.Address.City,deepCopyClassB.Address.City));deepCopyClassB.DemoEnum=DemoEnum.EnumB;WriteLog(string.Format("DemoEnum->[A:{0}][B:{1}]",deepCopyClassA.DemoEnum,deepCopyClassB.DemoEnum));deepCopyClassB.TestB.Property1="TestPropertyB";WriteLog(string.Format("Property1->[A:{0}][B:{1}]",deepCopyClassA.TestB.Property1,deepCopyClassB.TestB.Property1));WriteLog(string.Format("TestB.DeepCopyClass.Name->[A:{0}][B:{1}]",deepCopyClassA.TestB.DeepCopyClass.Name,deepCopyClassB.TestB.DeepCopyClass.Name));Console.WriteLine();}publicstaticvoidDeepCopyDemo2(){DeepCopyDemoClassdeepCopyClassA=newDeepCopyDemoClass();deepCopyClassA.Name="DeepCopyClassDemo";deepCopyClassA.pIntArray=newint[]{1,2};deepCopyClassA.DemoEnum=DemoEnum.EnumA;deepCopyClassA.Address=newAddress(){City="Shanghai"};deepCopyClassA.TestB=newTestB(){Property1="TestProperty",DeepCopyClass=deepCopyClassA};//使用反射来完成深拷贝DeepCopyDemoClassdeepCopyClassB=DeepCopyHelper.DeepCopyWithReflection_Second<DeepCopyDemoClass>(deepCopyClassA);//DeepCopyDemoClassdeepCopyClassB=DeepCopyHelper.DeepCopyWithReflection<DeepCopyDemoClass>(deepCopyClassA);deepCopyClassB.Name="DeepCopyClassDemoB";WriteLog(string.Format("Name->[A:{0}][B:{1}]",deepCopyClassA.Name,deepCopyClassB.Name));deepCopyClassB.pIntArray[0]=2;WriteLog(string.Format("intArray->[A:{0}][B:{1}]",deepCopyClassA.pIntArray[0],deepCopyClassB.pIntArray[0]));deepCopyClassB.Address=newAddress(){City="Beijing"};WriteLog(string.Format("Addressstruct->[A:{0}][B:{1}]",deepCopyClassA.Address.City,deepCopyClassB.Address.City));deepCopyClassB.DemoEnum=DemoEnum.EnumB;WriteLog(string.Format("DemoEnum->[A:{0}][B:{1}]",deepCopyClassA.DemoEnum,deepCopyClassB.DemoEnum));deepCopyClassB.TestB.Property1="TestPropertyB";WriteLog(string.Format("Property1->[A:{0}][B:{1}]",deepCopyClassA.TestB.Property1,deepCopyClassB.TestB.Property1));WriteLog(string.Format("TestB.DeepCopyClass.Name->[A:{0}][B:{1}]",deepCopyClassA.TestB.DeepCopyClass.Name,deepCopyClassB.TestB.DeepCopyClass.Name));Console.ReadKey();}}

　　此时的运行结果如下图所示：

　　刚开始看到这样的运行结果，开心地以为已经解决了循环递归的问题了，因为此时结果成功运行出来了，没有了StackOverflower的错误了。但是仔细一看，反序列化和反射完成的深拷贝的运行结果不一样，如上图中红色圈出来的部分。显然，反序列化的结果是没有错误的，显然目前实现的反射代码还是有问题的。接下来就是思考了。为什么上面反射的代码不正确呢？

　　仔细分析DeepCopyWithReflection_Second中的代码，发现下面代码红色部分是错误的：

intreflectionCount=Add(typereflectionCountDic,obj.GetType());if(reflectionCount>1)returnobj;//是错误的

　　对DeepCopyWithReflection_Second方法仔细分析，在对TestB进行反射时，当反射到DeepCopyClass属性时，此时会递归调用DeepCopyWithReflection_Second方法，此时在typereflectionCountDic发现DeepCopyDemoClass已经被反射了，则直接返回，这样分析好像没什么错误，但是此时返回的是deepCopyClassA对象，但是我们需要返回的是deepCopyClassB对象，即此时deepCopyClassB对象的内存结构如下图所示：

　　而我们其实需要deepCopyClassB对象的内存结构如下图所示：

　　既然找到了DeepCopyWithReflection_Second的错误原因，那我们就要解决了。上面说我们返回的应该是deepCopyClassB对象，而我们怎么得到创建的deepCopyClassB对象呢？这里我就想能不能用一个变量来保存一开始通过CreateInstance方法创建的deepCopyClassB对象呢？验证想法最好的办法就是代码了，这样我就按照这个思路对DeepCopyWithReflection_Second又进行一次改进，最终的代码如下所示：

publicstaticTDeepCopyWithReflection_Third<T>(Tobj){Typetype=obj.GetType();//如果是字符串或值类型则直接返回if(objisstring||type.IsValueType)returnobj;if(type.IsArray){TypeelementType=Type.GetType(type.FullName.Replace("[]",string.Empty));vararray=objasArray;Arraycopied=Array.CreateInstance(elementType,array.Length);for(inti=0;i<array.Length;i++){copied.SetValue(DeepCopyWithReflection_Second(array.GetValue(i)),i);}return(T)Convert.ChangeType(copied,obj.GetType());}intreflectionCount=Add(typereflectionCountDic,obj.GetType());if(reflectionCount>1&&obj.GetType()==typeof(DeepCopyDemoClass))return(T)DeepCopyDemoClasstypeRef;//返回deepCopyClassB对象objectretval=Activator.CreateInstance(obj.GetType());if(retval.GetType()==typeof(DeepCopyDemoClass))DeepCopyDemoClasstypeRef=retval;//保存一开始创建的DeepCopyDemoClass对象PropertyInfo[]properties=obj.GetType().GetProperties(BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Instance|BindingFlags.Static);foreach(varpropertyinproperties){varpropertyValue=property.GetValue(obj,null);if(propertyValue==null)continue;property.SetValue(retval,DeepCopyWithReflection_Third(propertyValue),null);}return(T)retval;}

下面我用DeepCopyWithReflection_Third方法来测试下，具体的测试代码如下所示：

classProgram{staticvoidMain(string[]args){//ShallowCopyDemo();//ListShallowCopyDemo();DeepCopyDemo();DeepCopyDemo2();}privatestaticvoidWriteLog(stringmsg){Console.WriteLine(msg);}publicstaticvoidDeepCopyDemo(){DeepCopyDemoClassdeepCopyClassA=newDeepCopyDemoClass();deepCopyClassA.Name="DeepCopyClassDemo";deepCopyClassA.pIntArray=newint[]{1};deepCopyClassA.DemoEnum=DemoEnum.EnumA;deepCopyClassA.Address=newAddress(){City="Shanghai"};deepCopyClassA.TestB=newTestB(){Property1="TestProperty",DeepCopyClass=deepCopyClassA};//使用反序列化来实现深拷贝DeepCopyDemoClassdeepCopyClassB=DeepCopyHelper.DeepCopyWithBinarySerialize<DeepCopyDemoClass>(deepCopyClassA);deepCopyClassB.Name="DeepCopyClassDemoB";WriteLog(string.Format("Name->[A:{0}][B:{1}]",deepCopyClassA.Name,deepCopyClassB.Name));deepCopyClassB.pIntArray[0]=2;WriteLog(string.Format("intArray->[A:{0}][B:{1}]",deepCopyClassA.pIntArray[0],deepCopyClassB.pIntArray[0]));deepCopyClassB.Address=newAddress(){City="Beijing"};WriteLog(string.Format("Addressstruct->[A:{0}][B:{1}]",deepCopyClassA.Address.City,deepCopyClassB.Address.City));deepCopyClassB.DemoEnum=DemoEnum.EnumB;WriteLog(string.Format("DemoEnum->[A:{0}][B:{1}]",deepCopyClassA.DemoEnum,deepCopyClassB.DemoEnum));deepCopyClassB.TestB.Property1="TestPropertyB";WriteLog(string.Format("Property1->[A:{0}][B:{1}]",deepCopyClassA.TestB.Property1,deepCopyClassB.TestB.Property1));WriteLog(string.Format("TestB.DeepCopyClass.Name->[A:{0}][B:{1}]",deepCopyClassA.TestB.DeepCopyClass.Name,deepCopyClassB.TestB.DeepCopyClass.Name));Console.WriteLine();}publicstaticvoidDeepCopyDemo2(){DeepCopyDemoClassdeepCopyClassA=newDeepCopyDemoClass();deepCopyClassA.Name="DeepCopyClassDemo";deepCopyClassA.pIntArray=newint[]{1,2};deepCopyClassA.DemoEnum=DemoEnum.EnumA;deepCopyClassA.Address=newAddress(){City="Shanghai"};deepCopyClassA.TestB=newTestB(){Property1="TestProperty",DeepCopyClass=deepCopyClassA};//使用反射来完成深拷贝DeepCopyDemoClassdeepCopyClassB=DeepCopyHelper.DeepCopyWithReflection_Third<DeepCopyDemoClass>(deepCopyClassA);//DeepCopyDemoClassdeepCopyClassB=DeepCopyHelper.DeepCopyWithReflection<DeepCopyDemoClass>(deepCopyClassA);deepCopyClassB.Name="DeepCopyClassDemoB";WriteLog(string.Format("Name->[A:{0}][B:{1}]",deepCopyClassA.Name,deepCopyClassB.Name));deepCopyClassB.pIntArray[0]=2;WriteLog(string.Format("intArray->[A:{0}][B:{1}]",deepCopyClassA.pIntArray[0],deepCopyClassB.pIntArray[0]));deepCopyClassB.Address=newAddress(){City="Beijing"};WriteLog(string.Format("Addressstruct->[A:{0}][B:{1}]",deepCopyClassA.Address.City,deepCopyClassB.Address.City));deepCopyClassB.DemoEnum=DemoEnum.EnumB;WriteLog(string.Format("DemoEnum->[A:{0}][B:{1}]",deepCopyClassA.DemoEnum,deepCopyClassB.DemoEnum));deepCopyClassB.TestB.Property1="TestPropertyB";WriteLog(string.Format("Property1->[A:{0}][B:{1}]",deepCopyClassA.TestB.Property1,deepCopyClassB.TestB.Property1));WriteLog(string.Format("TestB.DeepCopyClass.Name->[A:{0}][B:{1}]",deepCopyClassA.TestB.DeepCopyClass.Name,deepCopyClassB.TestB.DeepCopyClass.Name));Console.ReadKey();}}

此时的运行结果如下图示所示：

　　从上面的测试结果可以看出，此时深拷贝的反射实现方法基本上没什么问题了。这个方法也同时解决了相互引用对象的循环递归问题。

　　到这里，该文章的内容就结束。这里主要记录下自己在一次面试过程中遇到问题的一次总结，从中可以看出，反射进行深拷贝会有很多其他的问题，所以平时还是建议大家使用序列化的形式来进行深拷贝。

　　最后附上本文所有×××：DeepCopy.zip