转载请注明出处 ****https://cloud.tencent.com/developer/user/1605429
本篇文章主要讲解NSCopying
协议,以及NSCoding
协议实现对象的序列化和反序列化,实际开发中如果要自己造轮子这两个协议还是比较重要的。
Foundation
框架中为我们提供的基础的类基本都实现了NSCopying
协议,因此,我们可以使用copy
方法用来获取对象的一个不可变副本对象,可以使用mutableCopy
方法用来获取对象的一个可变副本对象,当需要对自定义类调用copy
或mutableCopy
方法就需要实现NSCopying
协议。首先我们看一下NSString
类的复制操作。有如下代码:
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSString *string = @"Jiaming Chen";
NSString *copyString = [string copy];
NSMutableString *mutableCopyString = [string mutableCopy];
//输出: 0x1000020a8 0x1000020a8 0x10058ccb0
NSLog(@"%p %p %p", string, copyString, mutableCopyString);
NSMutableString *mutableString = [[NSMutableString alloc] initWithString:@"Jiaming Chen"];
NSString *copyMutableString = [mutableString copy];
NSMutableString *mutableCopyMutableString = [mutableString mutableCopy];
//输出: 0x100403f90 0x100403ef0 0x100403fd0
NSLog(@"%p %p %p", mutableString, copyMutableString, mutableCopyMutableString);
NSString *str = [[NSMutableString alloc] initWithString:@"Jiaming Chen"];
NSString *copyStr = [str copy];
NSMutableString *mutableCopyStr = [str mutableCopy];
//输出: 0x100404060 0x7fffa86ddd40 0x1004040a0
NSLog(@"%p %p %p", str, copyStr, mutableCopyStr);
NSString *errorStr = @"Jiaming Chen";
NSMutableString *errorMutableStr = errorStr;
NSString *copyErrorMutableStr = [errorMutableStr copy];
NSMutableString *mutableCopyErrorMutableStr = [errorMutableStr mutableCopy];
//输出: 0x100002060 0x100002060 0x100002060 0x10440fbb0
NSLog(@"%p %p %p %p", errorStr, errorMutableStr, copyErrorMutableStr, mutableCopyErrorMutableStr);
}
}
上面的栗子,构造了四组实验:
第一组创建了一个NSString
类型的对象,接下来使用copy
和mutableCopy
方法分别获取不可变副本对象和可变副本对象,最后输出三者的地址,可以发现原对象和不可变副本对象的地址一致,而可变对象的地址发生了变化。
第二组创建了一个NSMutableString
类型的对象,同样获取了不可变和可变副本对象,输出的结果发现三者的地址都不同了。
第三组实验使用多态的方式创建了一个编译时类型为NSString
而运行时为NSMutableString
的对象,并获取可变和不可变副本对象,输出地址发现三者的地址都不同了。
第四组实验其实有些问题,errorMutableStr
是NSMutableString
类型的,但我们将NSString
类型的对象赋给了它,所以运行时它的类型仍为NSString
类型,但如果运行时调用了errorMutableStr
的可变方法如appendString:
等就会抛出异常。之所以这样做是为了和第三组实验进行对比,同样来获取可变和不可变副本对象,并输出地址,发现只有mutableCopy
的方法的地址不同。
通过对比上面四组实验的mutableCopy
复制可变副本对象的结果来看,我们可以发现,不论原对象是否可变,复制可变副本对象都会获取一个全新的对象,因为地址与原对象不同,因此即时修改也互不影响。接下来观察copy
不可变副本对象的实验,我们发现如果原对象运行时类型是不可变的使用copy
以后获取的是原对象的地址,并没有创建一个全新的对象,因为,原对象本身就是不可变的,复制一个不可变对象没有太大的实际意义,直接使用原对象即可,如果原对象的运行时类型是可变的,使用copy
以后获取的是一个全新的对象,这样就可以避免多态时的错误。
可以总结出如下表格:
type | copy | mutableCopy |
---|---|---|
NS* | 浅拷贝,只拷贝指针,地址相同 | 单层深拷贝,拷贝内容,地址不同 |
NSMutable* | 单层深拷贝,拷贝内容,地址不同 | 单层深拷贝,拷贝内容,地址不同 |
由上述表格可以看出,对于不可变类型,使用copy
方法时是浅拷贝,只拷贝指针,因为内容是不会变化的。使用mutableCopy
时由于返回可变对象因此需要一份拷贝,供其他对象使用。对于可变类型,不管是copy
还是mutableCopy
均会进行单层深拷贝,所指向指针不同。
对于容器类型的对象,copy
和mutableCopy
与上述实验效果一直,容器类型的复制不会进行彻底的深拷贝,只会实现单层深拷贝,即创建一个新的容器,但容器里的内容只是对原对象容器的内容进行浅拷贝即只拷贝地址,如果要实现真正的深拷贝需自行实现相关方法。
学习完了Foundation
框架提供的类的相关复制操作,接下将针对自定义类型的复制操作进行讲解,如果需要自定义类型支持复制的操作需要实现NSCopying
协议,并实现copyWithZone:
方法而不是重写copy
方法,举个栗子如下:
@interface Account: NSObject <NSCopying>
@property (nonatomic, strong) NSMutableString *accountNumber;
@property (nonatomic, assign) double balance;
@end
@implementation Account
@synthesize accountNumber = _accountNumber;
@synthesize balance = _balance;
- (instancetype)copyWithZone:(NSZone *)zone
{
//调用NSObject的类方法allocWithZone创建一个新的对象
Account *account = [[self class] allocWithZone:zone];
//使用mutableCopy获取一个可变的副本对象实现深拷贝
//如果不调用mutableCopy而直接赋值,则是浅拷贝,另一个对象的修改会影响到当前对象的值
account.accountNumber = [self.accountNumber mutableCopy];
account.balance = self.balance;
return account;
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSMutableString *mutableStr = [[NSMutableString alloc] initWithString:@"Jiaming Chen"];
Account *account = [[Account alloc] init];
account.accountNumber = mutableStr;
account.balance = 666.66;
Account *accountBak = [account copy];
//输出:0x100407460 0x100407580
NSLog(@"%p %p", account, accountBak);
//输出:0x1004074d0 0x100407600 0x100407be0
NSLog(@"%p %p %p", account.accountNumber, accountBak.accountNumber, mutableStr);
}
return 0;
}
上面举的栗子很简单,自定义了一个Account
类,其中为了实验方便定义的是NSMutableString
类型的accountNumber
属性,并且使用了strong
修饰符,关于使用copy
、strong
修饰符的问题有不明白的读者可以阅读本博客另一篇文章iOS @property探究(一): 基础详解,该类遵守NSCopying
协议并实现了copyWithZone:
方法,在实现方法中首先调用了NSObject
类的allocWithZone:
方法来创建一个新的对象,如果继承的不是NSObject
类,而是继承其他自定义类,如果继承的父类没有实现NSCopying
协议这里不能使用allocWithZone:
方法来创建新的对象,而应该使用alloc
和init
方法,如果继承的父类实现了NSCopying
协议,这里需要调用父类的方法来初始化,即调用[super copy]
方法来创建一个全新的对象,接下来就可以按照需要进行深拷贝或浅拷贝了。
对于NSCopying
协议,需要注意的就是可变对象和不可变对象之间的区别,以及父类有没有实现NSCopying
协议来确定调用何种方法来创建新对象。
在开发中可能需要将自定义对象持久化存储在本地的文件中,或将对象转换为NSData
类的数据并通过网络发送,要实现这些操作的前提就是自定义对象需要遵守NSCoding
协议,NSCoding
协议是对象序列化和反序列化的基础,NSCoding
协议只定义了两个方法:
/*将对象编码
序列化对象时调用该方法,在该方法中序列化对象的每一个属性
一般使用encodeObject:forKey:方法序列化属性
*/
- (void)encodeWithCoder:(NSCoder *)aCoder;
/*
将数据解码并创建一个对象
反序列化时调用该方法,在该方法中反序列化对象的每一个熟悉
一般使用decodeObject:forKey方法反序列化属性
*/
- (nullable instancetype)initWithCoder:(NSCoder *)aDecoder;
举个栗子如下:
@interface Account: NSObject <NSCoding>
@property (nonatomic, copy) NSString *accountNumber;
@property (nonatomic, assign) double balance;
@end
@implementation Account
@synthesize accountNumber = _accountNumber;
@synthesize balance = _balance;
//反序列化
- (instancetype)initWithCoder:(NSCoder *)aDecoder
{
/*NSObject没有遵守NSCoding协议,因此调用父类的init构造方法
如果继承的父类遵守NSCoding协议需要调用父类的initWithCoder:方法
[super initWithCoder:aDecoder]
*/
if (self = [super init])
{
self.accountNumber = [aDecoder decodeObjectForKey:@"kaccountNumber"];
self.balance = [aDecoder decodeDoubleForKey:@"kbalance"];
}
return self;
}
//序列化
- (void)encodeWithCoder:(NSCoder *)aCoder
{
//序列化与序列化的顺序不需要保持一致,因为使用了key来检索,可以乱序
[aCoder encodeObject:self.accountNumber forKey:@"kaccountNumber"];
[aCoder encodeDouble:self.balance forKey:@"kbalance"];
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
Account *account = [[Account alloc] init];
account.accountNumber = @"1603121434";
account.balance = 666.66;
//输出: <Account: 0x10040c2f0> 1603121434 666.660000
NSLog(@"%@ %@ %lf", account, account.accountNumber, account.balance);
//将对象持久化到本地文件
[NSKeyedArchiver archiveRootObject:account toFile:@"account.archiver"];
//从本地文件中将数据反序列化创建对象
Account *a = [NSKeyedUnarchiver unarchiveObjectWithFile:@"account.archiver"];
//输出: <Account: 0x100506860> 1603121434 666.660000
NSLog(@"%@ %@ %lf", a, a.accountNumber, a.balance);
}
return 0;
}
上面的栗子自定义了一个Account
类,遵守NSCoding
协议并实现了相关序列化和反序列化方法。栗子比较简单不再赘述。通过对象的序列化其实可以实现真正意义上的深拷贝,因为Foundation
提供的数据类型包括集合类型基本都实现了NSCoding
协议,因此,都可以实现序列化,序列化时将对象转换为字节码,反序列化时再将字节码反序列化为对应数据类型的数据,通过序列化和反序列化就可以实现真正意义的深拷贝,这里不再举栗子了。
上述举的栗子使用NSKeyedArchiver
的archiveRootObject:toFile
方法只能将一个对象持久化在一个文件中,如果要持久化多个对象只能分别存放在多个文件中,这样即浪费资源又比较复杂,NSKeyedArchiver
提供了使用NSMutableData
类的方式来实现多对象持久化到一个NSMutableData
中,因此也可以持久化到一个文件中,这里不再举相关栗子了,有需要的读者可以自行查阅。
关于NSCoding
协议的使用是比较简单的,需要注意的就是在initWithCoder:
方法中调用父类构造函数的方式。
由于作者水平有限,难免出现纰漏,如有问题还请不吝赐教。