• 类方法
  • 类变量
    • @synthesize 和 @dynamic
  • 类的扩展——Protocol, Category 和 Extension
    • Protocol
      • 含有 property 的 Protocol
    • Category
    • Extension
      • 如何给已有的类添加属性
      • 如何在类中添加全局变量
  • 类的导入
  • 类的初始化
    • +load
    • +initialize
  • 注解
  • 参考资料

    类方法

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

    1. @interface Controller : NSObject
    2. + (void)thisIsAStaticMethod; // 静态方法
    3. (void)thisIsAnInstanceMethod; // 实例方法
    4. @end

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

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

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

    1. // AClass.h
    2. @interface AClass : NSObject
    3. -(void)sayHello;
    4. @end
    5. // AClass.m
    6. @interface AClass (private)
    7. -(void)privateSayHello;
    8. @end
    9. @implementation AClass
    10. -(void)sayHello {
    11. [self privateSayHello];
    12. }
    13. -(void)privateSayHello {
    14. NSLog(@"Private Hello");
    15. }

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

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

    1. #import "SystemClass+CategoryName.h"
    2. @implementation SystemClass ( CategoryName )
    3. // method definitions
    4. @end

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

    1. // AClass.h 与上面相同
    2. // AClass.m
    3. @interface AClass()
    4. -(void)privateSayHello;
    5. @end
    6. @implementation AClass
    7. -(void)sayHello {
    8. [self privateSayHello];
    9. }
    10. -(void)privateSayHello {
    11. NSLog(@"Private Hello");
    12. }
    13. @end

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

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

    类变量

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

    1. @interface AClass : NSObject
    2. @property (nonatomic, copy) NSString *name;
    3. @end

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

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

    1. // AClass.h
    2. @interface AClass : NSObject{
    3. @public
    4. NSString *_name;
    5. }
    6. -(NSString*)name;
    7. -(void)setName:(NSString*)newName;
    8. @end
    9. // AClass.m
    10. @implementation AClass
    11. -(NSString*)name{
    12. return _name;
    13. }
    14. -(void)setName:(NSString *)name{
    15. if (_name != name) {
    16. [_name release];
    17. _name = [name copy];
    18. }
    19. }
    20. @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
    4. @interface B : NSObject<TestProtocol>
    5. -(void)print; // 默认方法是 @required 的,即必须实现
    6. @end

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

    含有 property 的 Protocol

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

    1. @class ExampleClass;
    2. @protocol ExampleProtocol
    3. @required
    4. @property (nonatomic, retain) ExampleClass *item;
    5. @end

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

    1. @interface MyObject : NSObject <ExampleProtocol>
    2. @property (nonatomic, retain) ExampleClass *item;
    3. @end

    要么进行手动 synthesize:

    1. @interface MyObject : NSObject <ExampleProtocol>
    2. @end
    3. @implementation MyObject
    4. @synthesize item;
    5. @end

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

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

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

    1. @interface AppDelegate : UIResponder <UIApplicationDelegate>
    2. @property (nonatomic, strong) UIWindow *window;
    3. @end

    Category

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

    Category 常见的使用方法如下:

    1. // SomeClass.h
    2. @interface SomeClass : NSObject{
    3. }
    4. -(void)print;
    5. @end
    6. // SomeClass+Hello.h
    7. #import "SomeClass.h"
    8. @interface SomeClass (Hello)
    9. -(void)hello;
    10. @end
    11. // 实现
    12. #import "SomeClass+Hello.h"
    13. @implementationSomeClass (Hello)
    14. -(void)hello{
    15. NSLog(@"name:%@ ", @"Jacky");
    16. }
    17. @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
    4. @interface MyClass () { // 注意此处扩展的写法
    5. float value;
    6. }
    7. - (void)setValue:(float)newValue;
    8. @end
    9. @implementation MyClass
    10. - (float)value {
    11. return value;
    12. }
    13. - (void)setValue:(float)newValue {
    14. value = newValue;
    15. }
    16. @end

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

    XYZPerson.h

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

    XYZPerson.m

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

    如何给已有的类添加属性

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

    1. @interface XYZPerson (UDID)
    2. @property (readwrite) NSString *uniqueIdentifier;
    3. @end
    4. @implementation XYZPerson (UDID)
    5. ...
    6. @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;
    2. @implementation XYZPerson
    3. ...
    4. @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. });
    7. return af_url_session_manager_creation_queue;
    8. }

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

    1. __attribute__((constructor))
    2. static void initialize_Queue() {
    3. _personOperationQueue = [[NSOperationQueue alloc] init];
    4. }
    5. @implementation XYZPerson (Operation)
    6. @end

    类的导入

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

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

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

    类的初始化

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

    +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 方法。 暂时没找到例子可以严格的证明此前的结论,所以还是去看源码吧。↩

    参考资料

    • iOS开发基础面试题系列
    • 10个Objective-C基础面试题,iOS面试必备
    • Objective-C中“私有方法”的实现”
    • Objective-C中@property详解
    • Objective-C中的protocol和delegate
    • Objective-C——消息,Category 与 Protocol
    • 深入理解Objective-C中的@class
    • Objective-C +load vs +initialize
    • 深入理解Objective-C:Category
    • https://stackoverflow.com/questions/19784454/when-should-i-use-synthesize-explicitly
    • http://www.fantageek.com/blog/2014/07/13/property-in-protocol/
    • http://www.friday.com/bbum/2009/09/06/iniailize-can-be-executed-multiple-times-load-not-so-much/