iOS创建对象的不同姿势详解

前言

在写 ios 代码的时候，怎么样去 new 一个新对象出来，都有一些讲究在里面。使用不同的姿势去创建对象，对后期维护所造成的影响会存在细微的差别。

init 创建

在之前一篇分析 ios 代码耦合的文章中，提到过当我们给一个对象的 property 赋值的时候，通过 init 方法传入参数来初始化 property 会让我们的代码更可靠。

有些人在定义带 property 的 class 的时候，会这样定义：

@interface user : nsobject
@property (nonatomic, strong) nsnumber*     userid;
@end

使用的时候如下：

user* user = [[user alloc] init];
user.userid = @1000;

尤其是在定义 model 的时候，很容易写出这种，先 init，而后挨个给 property 赋值的代码。这种代码的问题在于 property 对于外部是可写的，property 处于随时可能变化的状态。之前不少篇文章中都强调过 immutable 的重要性，同样对于一个 class，我们也应该优先考虑设计成 immutable 的。

initwith 创建

如果将 property 都设置成 readonly 的，或者不暴露 property，property 的赋值都通过 initwith 的方式来初始化，就可以得到一个具备 immutable 的 class 定义了，具体到上面的例子代码如下：

//user.h
@interface user : nsobject
@property (nonatomic, strong, readonly) nsnumber* userid;
- (instancetype)initwithuserid:(nsnumber*)uid;
@end
 
//user.m
@implementation user
- (instancetype)initwithuserid:(nsnumber*)uid {
 self = [super init];
 if (!self) {
  return nil;
 }
 _userid = uid;
 return self;
}
@end

userid 在 .h 文件当中是 readonly 的，userid 只有一次被赋值的机会，即在 user 的 initwith 方法中。这种方式的好处是一旦 user 对象创建完毕之后，就处于 immutable 的状态，property 都是不可修改的，安全可靠。

designated initializer

apple 为了方便开发者使用 init 方法，引入了一种名为 designated initializer 的 pattern。主要用来管理当一个 class 拥有多个 property 需要赋值的场景。比如上面我们的 user 类：

@interface user : nsobject
@property (nonatomic, strong, readonly) nsnumber*     userid;
@property (nonatomic, strong, readonly) nsstring*     username;
@property (nonatomic, strong, readonly) nsstring*     signature;
@end

有些场景需要初始化 userid 和 username，而有些场景只需要初始化 userid 和 signature，所以我们需要提供多个 initwith 方法给不同的场景使用。为了管理 initwith 方法，apple 将 init 方法分为两种类型：designated initializer 和 convenience initializer (又叫 secondary initializer) 。

designated initializer 只有一个，它会为 class 当中每个 property 都提供一个初始值，是最完整的 initwith 方法。convenience initializer 则可以有很多个，它可以选择只初始化部分的 property。convenience initializer 最后到会调用到 designated initializer，所以 designated initializer 也可以叫做 final initializer。

无论我们定义何种类型的 class，给 class 中的每个 property 都赋予一个初始值是个很好的习惯，可以避免掉一些意外的 bug 产生，这也是 designated initializer 的重要职责。

在实际的项目当中，一个 class 的 property 数目可能会随着业务的增长而增加，最后的结果就是会生成越来越多的 convenience initializer。上述的 user 类，如果是 3 个 property，极端的情况下最多可以有 7 个 init 方法。peak君在阅读代码的时候，也确实看到过有些 class 定义了一连串整整齐齐摆放的 init 方法，代码虽然看着规范，但显得啰嗦，而且每次需要肉眼搜索适合的 init 方法。

其实我们还可以用另一种姿势来 init 我们的对象。

builder pattern

最初是在学习 android 的时候，发现这个 builder pattern 也可以用来构建对象，而且可以很好的解决 init 方法过多难以管理的问题。先来看下如何实现，顾名思义，builder pattern 使用另一个名为 builder 的类来创建我们的目标对象，还是上面的例子，代码如下：

//userbuilder.h
@interface userbuilder : nsobject
@property (nonatomic, strong, readonly) nsnumber*     userid;
@property (nonatomic, strong, readonly) nsstring*     username;
@property (nonatomic, strong, readonly) nsstring*     signature;

- (userbuilder*)userid:(nsnumber*)userid;
- (userbuilder*)username:(nsstring*)username;
- (userbuilder*)signature:(nsstring*)signature;
@end

//userbuilder.m
@implementation userbuilder
- (userbuilder*)userid:(nsnumber*)userid {
 _userid = userid;
 return self;
}
- (userbuilder*)username:(nsstring*)username {
 _username = username;
 return self;
}
- (userbuilder*)signature:(nsstring*)signature {
 _signature = signature;
 return self;
}
@end

接下来 user 的 init 方法从 builder 中获取 property 的初始值：

//user.h
@interface user : nsobject
@property (nonatomic, strong, readonly) nsnumber*     userid;
@property (nonatomic, strong, readonly) nsstring*     username;
@property (nonatomic, strong, readonly) nsstring*     signature;

- (instancetype)initwithuserbuilder:(userbuilder*)builder;
@end
 
//user.m
@implementation user
- (instancetype)initwithuserbuilder:(userbuilder*)builder {
 self = [super init];
 if (!self) {
  return nil;
 }
 
 _userid = builder.userid;
 _username = builder.username;
 _signature = builder.signature;
 
 return self;
}
@end

如果要创建 user 对象，则按照这种方式：

userbuilder* builder = [[[[userbuilder new] username:@"peak"] userid:@1000] signature:@"roll"];
user* user = [[user alloc] initwithuserbuilder:builder];

这样我们避免了书写多个 init 方法，同样 user 对象也是 immutable 的，也做到了只在 init 方法中做一次赋值操作，每个场景都可以按照自己的需求初始化部分 property，当然最后我们需要在 initwithuserbuilder 中为每一个 property 赋值， initwithuserbuilder 扮演的角色类似于 designated initializer。

追求代码美感的同学可能发现了， userbuilder 的创建语法很丑陋，多个 [ ] 套嵌使用。为了让代码更好看一些，我们也可以使用 block 来创建：

user* user = [user userwithblock:^(userbuilder* builder) {
 builder.username = @"peak";
 builder.userid = @1000;
 builder.signature = yes;
}];

builder pattern 在 android 平台使用的比较多，我在 ios 平台上鲜少有看到使用的场景。builder pattern 的不足之处也比较明显，需要另外定义一个 builder 类，多写一些代码（property 基本都重复写了一遍）。个人觉得，在 property 数量较多，初始化的场景也比较多的时候，在 ios 上使用 builder pattern 也会是个不错的方案。

designated initializer vs builder pattern，这二者之间的不同其实很好的体现了语言本身的差异性。学习过 java 的同学就能明白，在 java 的世界中，一切都是可以被封装成对象的，使用 java 的时候，经常要定义各式各样的辅助类来完成某个任务，好处是封装度高，类职责划分粒度小，缺点是类太多，有时候会为了封装而封装，某些场景代码反而不够直观。

经读者反馈，原来这篇文章的主题已经被写过了。看过之后发现比我写的更全面，推荐大家阅读，。

总结

以上就是这篇文章的全部内容了，本文简单梳理了下创建对象的不同姿势，希望对大家有些帮助。如果有疑问大家可以留言交流。