1.浅复制与深复制

在Objective-C中，基本数据类型（例如int、float、BOOL等）的复制比较简单，都是会在内存中对需要复制的变量创建一个副本，而对象的复制有两种形式：浅复制和深复制。

浅复制：将原始对象的指针值复制到副本中，即指针复制，原始对象和副本共享引用的数据，相当于创建了一个文件的快捷方式。

深复制：复制原始对象指针所引用的数据，并将其赋给副本对象，即内容复制，相当于创建了一份新的文件。

当为一个类的属性添加copy关键字时，那么对这个属性赋值时，就会执行深复制操作；当把属性关键字改为strong或者weak时，那么对这个属性赋值时，就会执行浅复制（只复制指针地址）。

 

2.可变对象复制与不可变对象复制

在Foundation框架中，常用的几个类，如NSString、NSArray以及NSDictionary都有其对应的可变子类。当对不同对象进行复制时，系统会采用不同的复制方式，有的采用浅复制，有的采用深复制，因此有必要提前了解对不同类型的对象进行复制时，是指针复制还是值复制。

在NSObject类中提供了两种复制的实例方法，copy和mutableCopy。当对象调用copy方法时，会返回NSCopying协议中的 copyWithZone: 方法的返回值，前提是对象在定义中遵守了NSCopying协议；当对象调用mutableCopy方法时，会返回NSCopying协议中的 mutableCopyWithZone: 方法的返回值，前提是对象在定义中遵守了NSCopying协议。

当对不同类型的对象分别使用copy和mutableCopy方法进行复制时，可能对应不同的复制类型（深复制或浅复制），这取决于类中 copyWithZone: 以及 mutableCopyWithZone: 方法的实现逻辑。

请记住以下结论：

（1）NSString类使用copy为浅复制（指针复制），使用mutableCopy为深复制；NSMutableString类使用copy或者mutableCopy均为深复制。

（2）NSArray类使用copy为浅复制，使用mutableCopy为深复制。另外，不论使用copy还是mutableCopy，容器内的对象都是浅复制。

（3）NSMutableArray类不论使用copy还是mutableCopy都为深复制，容器内的对象都是浅复制。

（4）NSDictionary类使用copy为浅复制，使用mutableCopy为深复制，容器内的对象都是浅复制。

（5）NSMutableDictionary类不论使用copy还是mutableCopy都为深复制，容器内的对象都是浅复制。

 

3.自定义对象的复制

在实际开发中，对于一些自定义的对象，有时也希望对其进行复制。对于自定义对象的复制，首先要保证在类的定义中遵守NSCopying协议，然后实现 copyWithZone: 方法。对于自定义对象的复制特性（浅复制或深复制），都取决于 copyWithZone: 方法中的实现情况，对于类中定义的属性也需要综合考虑其定义中有关内存管理的特性（strong/weak/copy/assign）。

（1）类的定义与复制

首先自定义ClassA类以及ClassB类，并在ClassB类中，添加4个属性，这4个属性分别使用了copy、strong、weak和assign关键字，如下所示。



为了实现对该类对象的复制，要求ClassB遵守NSCopying协议，同时在.m文件中实现 copyWithZone: 方法，在该方法中的实现逻辑决定了当调用copy方法时对该类对象进行复制所采取的方式（深复制或者浅复制）。

 

（2）浅复制该类对象

当仅仅需要对该对象进行浅复制时，可以在 copyWithZone: 方法中，直接返回要复制的对象即可。

在ClassB.m文件中，实现 copyWithZone: 方法。



 

（3）深复制该类对象

当需要对自定义对象深复制时，需要在 copyWithZone: 方法中调用alloc以及init方法，重新开辟一块新的内存空间。另外，对于属性的复制过程中，也需要考虑到属性自身的特性，例如：有copy特性的属性需要重新生成新的副本，strong以及weak只需要做指针复制即可。

在ClassB.m文件中，实现 copyWithZone: 方法。



 

（4）深复制与浅复制的代码验证

在main.m文件中，添加一个函数，用来复制ClassB的对象，代码如下所示。



 

当ClassB中的 copyWithZone: 方法中采用浅复制时，复制后得到的副本指向同一内存地址，即进行了指针复制，内容还是原来的内容。



 

当ClassB中的 copyWithZone: 方法中采用深复制时，可以看到复制得到的对象与原对象的地址不同，同时属性中包含copy关键字的属性在复制过程中也进行了深复制，而strong/weak特性的属性仅仅做了指针复制。



 

在我们工作中经常会用到对象复制的情况，比如 A对象为原有对象，把A对象赋值给B对象，记录原有数据，然后对A对象开始操作改变值，接着想知道 A都改变了那些值 

都会先这样写：

A a = new A();
a.ID = 10;
a.Name = "jacky";

A b = a;

a.ID = 11;
a.Name = "zhuovi";


然后 结果并不是我们想要的，a  b 两对象的值都被改变了。 

有两种对象克隆的方法：浅拷贝和深拷贝。浅拷贝只是复制引用，而不会复制引用的对象。深拷贝会复制引用的对象。 

原始对象中的引用和浅拷贝对象中的同一个引用都指向同一个对象。而深拷贝的对象包含了对象的一切直接或间接的引用。 

下边给出我经常用的两种方法 

1.MemberWiseClone 

MemberWiseClone是Object类的受保护方法，能够通过创建一个新对象，并把所有当前对象中的非静态域复制到新对象中，从而创建一 个浅拷贝。对于值类型的域，进行的是按位拷贝。对于引用类型的域，引用会被赋值而引用的对象则不会。因此，原始对象及其克隆都会引用同一个对象。注意，这种方法对派生类都是有效的，也就是说，你只需在基类中定义一次Clone方法。下面是一个简单的例子：

public class A{
    public int ID{get;set;}
    public string Name{get;set;}
    public A Clone(){
        return this.MemberWiseClone() as A;
    }
}


2.用反射进行克隆 

直接上代码



System.Reflection.PropertyInfo[] pA = A.GetType().GetProperties();
System.Reflection.PropertyInfo[] pB = A.GetType().GetProperties();
for (int i = 0; i < pA.Length; i++)
{
    if(pB[i].CanWrite)
    pB[i].SetValue(this, pA[i].GetValue(A, null));
}

当前了 还有一种 就是手动赋值 这个就不在这里说了 大家都知道 。

                            





1. 何时调用复制构造函数

　　复制构造函数用于将一个对象复制到新创建的对象中。也就是说，它用于初始化过程中，而不是常规的赋值过程中。类的复制构造函数原型通常如下：

　　class_name(const class_name&);

　　它接受一个指向类对象的常量引用作为参数。例如，String类的复制构造函数的原型如下：

　　String(const String&);

　　新建一个对象并将其初始化为同类现有对象时，复制构造函数都将被调用。这在很多情况下都可能发生，最常见的情况是将新对象显示地初始化为现有的对象。例如，假设motto是一个String对象，则下面4种声明都将调用复制构造函数：
　　String ditto(motto);

　　String metoo = motto;

　　String also = String(motto);

　　String *pString = new String(motto);

　　其中中间的2种声明可能会使用复制构造函数直接创建metto和also，也可能会使用复制构造函数生成一个临时对象，然后将临时对象的内容赋给 metoo和also，这取决于具体的实现。最后一种声明使用motto初始化一个匿名对象，并将新对象的地址赋给pString指针。
2. 何时调用赋值构造函数

　　赋值构造函数是通过重载赋值操作符实现的，这种操作符的原型如下：

　　Class_name& Class_name::operator=(const Class_name&);

　　它接受并返回一个指向类对象的引用。例如，String 类的赋值操作符的原型如下：

　　String& String::operator=(const String&);

　　将已有的对象赋给另一个对象时，将使用重载的赋值操作符：

　　String headline1(“test”);

　　String knot;

　　knot = headline1;

　　初始化对象时，并不一定会使用赋值操作符：

　　String metoo = knot;

　　这里，metoo是一个新创建的对象，被初始化为knot的值，考试,大提示使用复制构造函数。不过，正如前面指出的，实现时也可能分两步来处理这条语句：使用复制构造函数创建一个临时对象，然后通过赋值将临时对象的值复制到新对象中。这就是说，初始化总是会调用复制构造函数，而使用＝操作符时也可能调用赋值操作符

　　实例代码如下：

　　#include <iostream>

　　using namespace std;

　　class Test

　　{

　　public:

　　Test();

　　~Test();

　　Test(const Test& t);

　　Test& operator=(const Test& t);

　　private:

　　int t1;

　　};

　　Test::Test()

　　{

　　cout<<”调用构造函数”<<endl;

　　}

　　Test::~Test()

　　{

　　cout<<”调用析构函数”<<endl;

　　}

　　Test::Test(const Test& t)

　　{

　　cout<<”调用复制构造函数”<<endl;

　　}

　　Test& Test::operator =(const Test& t)

　　{

　　cout<<”调用赋值构造函数”<<endl;

　　t1 = t.t1;

　　return *this;

　　}

　　void main()

　　{

　　Test t1;

　　Test t2 = t1;

　　Test t3;

　　t3 = t1;

　　}

　　输出如下：

　　调用构造函数

　　调用复制构造函数

　　调用构造函数

　　调用赋值构造函数

　　调用析构函数

　　调用析构函数

　　调用析构函数





同样是利用现有对象的值，生成/更新另一个对象的值。区别在于：复制构造函数是去完成对未初始化的存储区的初始化，而赋值操作符则是处理一个已经存在的对象。对一个对象赋值，当它一次出现时，它将调用复制构造函数，以后每次出现，都调用赋值操作符。


定义对象a，并用另一个对象b对a进行初始化时，

若没有复制构造函数时，那么编译器会自动生成一个

T b(1);//假设对象b已经初始化

T a(b);//初试化阶段，调用复制构造函数

T c = b;//虽然使用了“=”，但是初试化阶段，仍调用复制构造函数

T c = a; //因为对象c已经定义，所以此处调用赋值操作符重载函数。如果没有编译器会自动生成一个。
                

                </div>

Spring BeanUtils 的对象复制 copyProperties