类方法

OC中类的方法只有实例方法和静态方法两种：

1. @interface Controller : NSObject

3. + (void)thisIsAStaticMethod; // 静态方法

5. – (void)thisIsAnInstanceMethod; // 实例方法

7. @end

OC 中的方法只要声明在 @interface里，就可以认为都是公有的。实际上，OC 没有像 Java，C++ 中的那种绝对的私有及保护成员方法，仅仅可以对调用者隐藏某些方法。

声明和实现都写在 @implementation 里的方法，类的外部是看不到的。

可以使用 Category 来实现私有方法：

1. // AClass.h
2. @interface AClass : NSObject

4. -(void)sayHello;

6. @end

8. // AClass.m
9. @interface AClass (private)

11. -(void)privateSayHello;

13. @end

15. @implementation AClass

17. -(void)sayHello {
18. [self privateSayHello];
19. }

21. -(void)privateSayHello {
22. NSLog(@"Private Hello");
23. }

使用这种方法时，外部就不能直接调用到 privateSayHello 方法。

注意在上面的代码里面，当我们想通过 Category 来进行方法隐藏的时候，我们可以把实现放在主 implementation 里。当我们想扩展别的不能获取到源代码的类，或者想把不同 Category 的实现分开，可以新建 <ClassName>+CategoryName.m 文件，在里面进行实现：

1. #import "SystemClass+CategoryName.h"

3. @implementation SystemClass ( CategoryName )
4. // method definitions
5. @end

也可以使用 Extension 来实现私有方法：

1. // AClass.h 与上面相同

3. // AClass.m
4. @interface AClass()

6. -(void)privateSayHello;

8. @end

10. @implementation AClass

12. -(void)sayHello {
13. [self privateSayHello];
14. }

16. -(void)privateSayHello {
17. NSLog(@"Private Hello");
18. }

20. @end

与使用 Category 类似，由于声明隐藏在 .m 中，调用者无法看到其声明，也就无法调用 privateSayHello 这个方法，会引发编译错误。

关于 Category 和 Extension 的一些区别，在这里。

类变量

苹果推荐在现代 Objective-C 中使用 @property 来实现成员变量：

1. @interface AClass : NSObject

3. @property (nonatomic, copy) NSString *name;

5. @end

使用 @property 声明的变量可以使用实例名.变量名来获取和修改。

@property 可以看做是一种语法糖，在 MRC 下，使用 @property 可以看成实现了下面的代码：

1. // AClass.h
2. @interface AClass : NSObject{
3. @public
4. NSString *_name;
5. }

7. -(NSString*)name;
8. -(void)setName:(NSString*)newName;
9. @end

11. // AClass.m
12. @implementation AClass

14. -(NSString*)name{
15. return _name;
16. }

18. -(void)setName:(NSString *)name{
19. if (_name != name) {
20. [_name release];
21. _name = [name copy];
22. }
23. }
24. @end

也就是说，@property 会自动生成 getter 和 setter， 同时进行自动内存管理。

@property 的属性可以有以下几种：

  • readwrite 是可读可写特性；需要生成 getter 方法和 setter 方法
  • readonly 是只读特性，只会生成 getter 方法 不会生成 setter 方法，不希望属性在类外改变时使用
  • assign 是赋值特性，setter 方法将传入参数赋值给实例变量；仅设置变量时；
  • retain 表示持有特性，setter 方法将传入参数先保留，再赋值，传入参数的 retain count 会+1;
  • copy 表示拷贝特性，setter 方法将传入对象复制一份；需要完全一份新的变量时。
  • nonatomic 和 atomic ，决定编译器生成的 setter getter是否是原子操作。 atomic 表示使用原子操作，可以在一定程度上保证线程安全。一般推荐使用 nonatomic ，因为 nonatomic 编译出的代码更快

默认的 @property 是 readwrite，assign，atomic。

同时，我们还可以使用自己定义 accessor 的名字：

1. @property (getter=isFinished) BOOL finished;

这种情况下，编译器生成的 getter 方法名为 isFinished，而不是 finished。

@synthesize 和 @dynamic

对于现代 OC 来说，在使用 @property 时， 编译器默认会进行自动 synthesize，生成 getter 和 setter，同时把 ivar 和属性绑定起来：

1. /// 现代 OC 不再需要手动进行下面的声明，编译器会自动处理
2. @synthesize propertyName = _propertyName

不需要我们写任何代码，就可以直接使用 getter 和 setter 了。

然而并不是所有情况下编译器都会进行自动 synthesize，具体由下面几种：

  • 可读写(readwrite)属性实现了自己的 getter 和 setter
  • 只读(readonly)属性实现了自己的 getter
  • 使用 @dynamic，显式表示不希望编译器生成 getter 和 setter
  • protocol 中定义的属性，编译器不会自动 synthesize，需要手动写
  • 当重载父类中的属性时，也必须手动写 synthesize

类的扩展——Protocol, Category 和 Extension

Protocol

OC是单继承的，OC中的类可以实现多个 protocol 来实现类似 C++ 中多重继承的效果。

Protocol 类似 Java 中的 interface，定义了一个方法列表，这个方法列表中的方法可以使用 @required， @optional 标注，以表示该方法是否是客户类必须要实现的方法。 一个 protocol 可以继承其他的 protocol 。

1. @protocol TestProtocol<NSObject> // NSObject也是一个 Protocol，这里即继承 NSObject 里的方法
2. -(void)print;
3. @end

5. @interface B : NSObject<TestProtocol>
6. -(void)print; // 默认方法是 @required 的，即必须实现
7. @end

Delegate（委托）是 Cocoa 中常见的一种设计模式，其实现依赖于 protocol 这个语言特性。

含有 property 的 Protocol

上面提到过，当 Protocol 中含有 property 时，编译器是不会进行自动 synthesize 的，需要手动处理：

1. @class ExampleClass;

3. @protocol ExampleProtocol

5. @required

7. @property (nonatomic, retain) ExampleClass *item;

9. @end

在实现这个 Protocol 的时候，要么再次声明 property：

1. @interface MyObject : NSObject <ExampleProtocol>

3. @property (nonatomic, retain) ExampleClass *item;

5. @end

要么进行手动 synthesize：

1. @interface MyObject : NSObject <ExampleProtocol>
2. @end

4. @implementation MyObject
5. @synthesize item;

7. @end

工程自带的 AppDelegate 使用了前一种方法，UIApplicationDelegate protocol 当中定义了 window 属性：

1. @property (nonatomic, retain) UIWindow *window NS_AVAILABLE_IOS(5_0);

在 AppDelegate.h 中我们可以看到再次对 windows 进行了声明：

1. @interface AppDelegate : UIResponder <UIApplicationDelegate>

3. @property (nonatomic, strong) UIWindow *window;

5. @end

Category

Category 是一种很灵活的扩展原有类的机制，使用 Category 不需要访问原有类的代码，也无需继承。Category提供了一种简单的方式，来实现类的相关方法的模块化，把不同的类方法分配到不同的类文件中。

Category 常见的使用方法如下：

1. // SomeClass.h
2. @interface SomeClass : NSObject{
3. }
4. -(void)print;
5. @end

7. // SomeClass+Hello.h
8. #import "SomeClass.h"

10. @interface SomeClass (Hello)
11. -(void)hello;
12. @end

14. // 实现
15. #import "SomeClass+Hello.h"
16. @implementationSomeClass (Hello)
17. -(void)hello{
18. NSLog(@"name：%@ ", @"Jacky");
19. }
20. @end

在使用 Category 时需要注意的一点是，如果有多个命名 Category 均实现了同一个方法（即出现了命名冲突），那么这些方法在运行时只有一个会被调用，具体哪个会被调用是不确定的。因此在给已有的类（特别是 Cocoa 类）添加 Category 时，推荐的函数命名方法是加上前缀：

1. @interface NSSortDescriptor (XYZAdditions)
2. + (id)xyz_sortDescriptorWithKey:(NSString *)key ascending:(BOOL)ascending;
3. @end

Extension

Extension 可以认为是一种匿名的 Category， Extension 与 Category 有如下几点显著的区别：

  1. 使用 Extension 必须有原有类的源码
  2. Extension 声明的方法必须在类的主 @implementation 区间内实现，可以避免使用有名 Category 带来的多个不必要的 implementation 段。
  3. Extension 可以在类中添加新的属性和实例变量，Category 不可以（注：在 Category 中实际上可以通过运行时添加新的属性，下面会讲到）
  4. ~~Extension 里添加的方法必须要有实现（没有实现编译器会给出警告）~~

注：现代 ObjC 中 Extension 和 Category 中声明的方法如果没有实现编译器都会给出警告。

下面是一个 Extension 的例子：

1. @interface MyClass : NSObject
2. - (float)value;
3. @end

5. @interface MyClass () { // 注意此处扩展的写法
6. float value;
7. }
8. - (void)setValue:(float)newValue;
9. @end

11. @implementation MyClass

13. - (float)value {
14. return value;
15. }

17. - (void)setValue:(float)newValue {
18. value = newValue;
19. }
20. @end

Extension 很常见的用法，是用来给类添加私有的变量和方法，用于在类的内部使用。例如在 interface 中定义为 readonly 类型的属性，在实现中添加 extension，将其重新定义为 readwrite，这样我们在类的内部就可以直接修改它的值，然而外部依然不能调用 setter 方法来修改。示例代码如下（来自苹果官方文档）:

XYZPerson.h

1. @interface XYZPerson : NSObject
2. ...
3. @property (readonly) NSString *uniqueIdentifier;

5. @end

XYZPerson.m

1. @interface XYZPerson ()
2. @property (readwrite) NSString *uniqueIdentifier;
3. @end

5. @implementation XYZPerson
6. ...
7. @end

如何给已有的类添加属性

首先强调一下上面例子中所展示的，Extension 可以给类添加属性，编译器会自动生成 getter，setter 和 ivar。 Category 并不支持这些。如果使用 Category 的话，类似下面这样：

1. @interface XYZPerson (UDID)
2. @property (readwrite) NSString *uniqueIdentifier;
3. @end

5. @implementation XYZPerson (UDID)
6. ...
7. @end

尽管编译可以通过，但是当真正使用 uniqueIdentifier 时直接会导致程序崩溃。

如果我们手动去 synthesize 呢？像下面这样：

1. @implementation XYZPerson (UDID)
2. @synthesize uniqueIdentifier;
3. ...
4. @end

然而这样做的话，代码直接报编译错误了：

@synthesize not allowed in a category's implementation

看来这条路是彻底走不通了。

不过我们还有别的方法，想通过 Category 添加属性的话，可以通过 Runtime 当中提供的 associated object 特性。NSHipster 的 这篇文章 展示了具体的做法。

如何在类中添加全局变量

有些时候我们需要在类中添加某个在类中全局可用的变量，为了避免污染作用域，一个比较好的做法是在 .m 文件中使用 static 变量：

1. static NSOperationQueue * _personOperationQueue = nil;

3. @implementation XYZPerson
4. ...
5. @end

由于 static 变量在编译期就是确定的，因此对于 NSObject 对象来说，初始化的值只能是 nil。如何进行类似 init 的初始化呢？可以通过重载 initialize 方法来做：

1. @implementation XYZPerson
2. - (void)initialize {
3. if (!_personOperationQueue) {
4. _personOperationQueue = [[NSOperationQueue alloc] init];
5. }
6. }
7. @end

为什么这里要判断是否为 nil 呢？因为 initialize 方法可能会调用多次，后面会提到。

如果是在 Category 中想声明全局变量呢？当然也可以通过 initialize，不过除非必须的情况下，并不推荐在 Category 当中进行方法重载。

有一种方法是声明 static 函数，下面的代码来自 AFNetworking，声明了一个当前文件范围可用的队列：

1. static dispatch_queue_t url_session_manager_creation_queue() {
2. static dispatch_queue_t af_url_session_manager_creation_queue;
3. static dispatch_once_t onceToken;
4. dispatch_once(&onceToken, ^{
5. af_url_session_manager_creation_queue = dispatch_queue_create("com.alamofire.networking.session.manager.creation", DISPATCH_QUEUE_SERIAL);
6. });

8. return af_url_session_manager_creation_queue;
9. }

下面介绍一个有点黑魔法的方法，除了上面两种方法之外，我们还可以通过编译器的 __attribute__ 特性来实现初始化：

1. __attribute__((constructor))
2. static void initialize_Queue() {
3. _personOperationQueue = [[NSOperationQueue alloc] init];
4. }

6. @implementation XYZPerson (Operation)

8. @end

类的导入

导入类可以使用 #include , #import 和 @class 三种方法，其区别如下：

  • #import是Objective-C导入头文件的关键字，#include是C/C++导入头文件的关键字
  • 使用#import头文件会自动只导入一次，不会重复导入，相当于#include和#pragma once；
  • @class告诉编译器需要知道某个类的声明，可以解决头文件的相互包含问题；

@class是放在interface中的，只是在引用一个类，将这个被引用类作为一个类型使用。在实现文件中，如果需要引用到被引用类的实体变量或者方法时，还需要使用#import方式引入被引用类。

类的初始化

Objective-C 是建立在 Runtime 基础上的语言，类也不例外。OC 中类是初始化也是动态的。在 OC 中绝大部分类都继承自 NSObject，它有两个非常特殊的类方法 load 和 initilize，用于类的初始化

+load

+load 方法是当类或分类被添加到 Objective-C runtime 时被调用的，实现这个方法可以让我们在类加载的时候执行一些类相关的行为。子类的 +load 方法会在它的所有父类的 +load 方法之后执行，而分类的 +load 方法会在它的主类的 +load 方法之后执行。但是不同的类之间的 +load 方法的调用顺序是不确定的。

load 方法不会被类自动继承, 每一个类中的 load 方法都不需要像 viewDidLoad 方法一样调用父类的方法。子类、父类和分类中的 +load 方法的实现是被区别对待的。也就是说如果子类没有实现 +load 方法，那么当它被加载时 runtime 是不会去调用父类的 +load 方法的1。同理，当一个类和它的分类都实现了 +load 方法时，两个方法都会被调用。因此，我们常常可以利用这个特性做一些“邪恶”的事情，比如说方法混淆（Method Swizzling）。FDTemplateLayoutCell 中就使用了这个方法，见这里。

+initialize

+initialize 方法是在类或它的子类收到第一条消息之前被调用的，这里所指的消息包括实例方法和类方法的调用。也就是说 +initialize 方法是以懒加载的方式被调用的，如果程序一直没有给某个类或它的子类发送消息，那么这个类的 +initialize 方法是永远不会被调用的。

+initialize 方法的调用与普通方法的调用是一样的，走的都是发送消息的流程。换言之，如果子类没有实现 +initialize 方法，那么继承自父类的实现会被调用；如果一个类的分类实现了 +initialize 方法，那么就会对这个类中的实现造成覆盖。

注解

  • 1.举一个例子：有一个 Father 类，实现了 load 方法，打印类名，一个 Son 类继承自前者，没有实现 load 方法。实例出一个 Son 的对象时，结果是会输出父类的名字。但这个例子与之前的结论并不矛盾，这里说的是父类先被加载了，所以调用了父类的 load 方法，而子类被加载时没有调用父类的 load 方法。 暂时没找到例子可以严格的证明此前的结论，所以还是去看源码吧。↩

### 参考资料