您的位置：首页 > 移动开发 > Objective-C

Objective-C 中 +load 与 +initialize

2015-06-16 13:56 555 查看

类的加载
在java语言里，可以通过如下代码来实现加载类的时候执行对类的操作，一般叫：类初始块，或者，类加载块。比如：

Java代码

public class MyClass{
    static{
        ……
    }
}

在objc语言里，对应的机制是，2个类初始化方法，+(void)load和+(void)initialize。
比如：

Java代码

#import "Constants.h"
@implementation Constants

+ (void)initialize{
    NSLog(@"init constants >>>>>>>>>>");
}

+ (void)load{
    NSLog(@"load constants >>>>>>>>>>");
}

@end

两个方法有一些不同。
load，是加载类的时候，这里是Constants类，就会调用。也就是说，ios应用启动的时候，就会加载所有的类，就会调用这个方法。

这样有个缺点，当加载类需要很昂贵的资源，或者比较耗时的时候，可能造成不良的用户体验，或者系统的抖动。这时候，就要考虑initialize方法了。这个方法可看作类加载的延时加载方法。类加载后并不执行该方法。只有当实例化该类的实例的时候，才会在第一个实例加载前执行该方法。比如：

[Constants alloc];
alloc将为Constants实例在堆上分配变量。这时调用一次initialize方法，而且仅调用一次，也就是说再次alloc操作的时候，不会再调用initialize方法了。
initialize 会在运行时仅被触发一次，如果没有向类发送消息的话，这个方法将不会被调用。这个方法的调用是线程安全的。父类会比子类先收到此消息。

如果希望在类及其Categorgy中执行不同的初始化的话可以使用+load
+(void)load; 在Objective-C运行时载入类或者Category时被调用
这个方法对动态库和静态库中的类或(Category)都有效.

在Mac OS X 10.5及之后的版本，初始化的顺序如下：
1. 调用所有的Framework中的初始化方法
2. 调用所有的+load方法
3. 调用C++的静态初始化方及C/C++中的__attribute__(constructor)函数
4.调用所有链接到目标文件的framework中的初始化方法
另外
* 一个类的+load方法在其父类的+load方法后调用
* 一个Category的+load方法在被其扩展的类的自有+load方法后调用
在+load方法中，可以安全地向同一二进制包中的其它无关的类发送消息，但接收消息的类中的+load方法可能尚未被调用。

下面是一个load的顺序

Java代码

#import <Foundation/Foundation.h>

#define LOAD +(void)load{NSLog(@"%s", __PRETTY_FUNCTION__);}
#define INITIALIZE +(void)initialize{NSLog(@"%s", __PRETTY_FUNCTION__);}
#define DEF_CLASS(clsName) @interface clsName : NSObject \
@end \
@implementation clsName \
INITIALIZE \
LOAD \
@end

DEF_CLASS(C1)   //1
DEF_CLASS(C2)   //2

@interface C1 (Hello)
+ (void)hello;
@end
@implementation C1 (Hello)
INITIALIZE       //4
LOAD            //3
+ (void)hello
{
    NSLog(@"Hello");
}
+ (void)hi
{
    NSLog(@"hi");
}
@end

@interface C2 (Hello)
@end
@implementation C2 (Hello)
+ (void)load    //5
{
    NSLog(@"%s", __PRETTY_FUNCTION__);//[C1 hello];//NSLog(@"%s", __PRETTY_FUNCTION__);
}

+ (void)initialize    //6
{
    NSLog(@"%s", __PRETTY_FUNCTION__);
}
@end
int main (int argc, const char * argv[])
{

    @autoreleasepool {
        // insert code here...
        [[C1 alloc]init]; // 向C1发送消息
        [[C2 alloc]init]; // 向C2发送消息
    }
    return 0;
}

输出：
2012-08-1400:55:26.769 www[741:903] +[C1 load]
2012-08-1400:55:26.772 www[741:903] +[C2 load]
2012-08-14 00:55:26.772 www[741:903] +[C1(Hello) load]
2012-08-14 00:55:26.773 www[741:903] +[C2(Hello) load]
2012-08-14 00:55:26.773 www[741:903] +[C1(Hello) initialize]
2012-08-14 00:55:26.774 www[741:903] +[C2(Hello) initialize]
貌似类中的initialize没有执行。alloc]init某个类就调用每个类的initialize方法。
假如只[[C2 alloc]init];就只执行C2类中的initialize方法，输出：

2012-08-1400:55:26.769 www[741:903] +[C1 load]
2012-08-1400:55:26.772 www[741:903] +[C2 load]
2012-08-14 00:55:26.772 www[741:903] +[C1(Hello) load]
2012-08-14 00:55:26.773 www[741:903] +[C2(Hello) load]
2012-08-14 00:55:26.774 www[741:903] +[C2(Hello) initialize]

再看下面代码：

Java代码

#import <Foundation/Foundation.h>

#define LOAD +(void)load{NSLog(@"%s", __PRETTY_FUNCTION__);}
#define INITIALIZE +(void)initialize{NSLog(@"%s", __PRETTY_FUNCTION__);}
#define DEF_CLASS(clsName) @interface clsName : NSObject \
@end \
@implementation clsName \
INITIALIZE \
LOAD \
@end

DEF_CLASS(C1)   //1
DEF_CLASS(C2)   //2

@interface C1 (Hello)
+ (void)hello;
@end
@implementation C1 (Hello)
INITIALIZE       //4
LOAD            //3
+ (void)hello
{
    NSLog(@"Hello");
}
+ (void)hi
{
    NSLog(@"hi");
}
@end

@interface C2 (Hello)
@end
@implementation C2 (Hello)
+ (void)load    //5
{
    [C1 hello];//NSLog(@"%s", __PRETTY_FUNCTION__); //这里做了修改，调用了C1的静态方法，导致执行了C1的+initialize
}

+ (void)initialize    //6
{
    NSLog(@"%s", __PRETTY_FUNCTION__);
}
@end
int main (int argc, const char * argv[])
{

    @autoreleasepool {
        // insert code here...
        //                [[C1 alloc]init]; // 向C1发送消息
        [[C2 alloc]init]; // 向C2发送消息
    }
    return 0;
}

输出：
2012-08-1423:31:28.834 www[14975:903] +[C1 load]
2012-08-1423:31:28.837 www[14975:903] +[C2 load]
2012-08-14 23:31:28.837 www[14975:903] +[C1(Hello) load]
2012-08-14 23:31:28.838 www[14975:903] +[C1(Hello) initialize]
2012-08-1423:31:28.838 www[14975:903] Hello
2012-08-14 23:31:28.839 www[14975:903] +[C2(Hello) initialize]

问题：
1，在倒数第二个代码中，为什么没有执行类中的initialize而是执行Category中的initialize方法？？（Category覆盖方法时优先级更高）

要点：
1、initialize和load，我们并不需要在这两个方法的实现中使用super调用父类的方法。(不需要调用父类的load函数，否则父类的load函数会多次执行)
2、load和initialize被调用一次是相对runtime而言，你可以当作普通类方法多次调用。

3、类加载到系统的时候就用调用load方法，类首次使用的时候调用initialize方法。

4、load不像普通方法一样遵从那套继承规则，当每个类没有实现 load方法，不管各级超类是否实现，系统都不会调用此类的load方法。initialize与其他方法一样，如果每个类没有实现initialize方法，而超类实现了，那么就会执行超类的这个方法，所以通常会：

Java代码

+(void)initialize{
if(self == [XXXClass clasee])
//todo
}

加了这个检测后，只会在期望的那个类被加载的时候执行。

5、initialize和load的方法必须写的精简。

6、initialize中可以实现无法在编译期初始化的全局变量，load的方法中可以实现swizzling的逻辑。

7、load的调用并不视为类的第一个方法完成，因为load中调用了当前类中的方法，就先去执行initialize方法了。

8、Runtime调用+(void)load时没有autorelease pool，

Java代码

@interface MainClass : NSObject
@end

@implementation MainClass

+ (void) load {
    NSArray *array = [NSArray array];
    NSLog(@"%@ %s", array, __FUNCTION__);
}

@end

objc[84934]: Object 0x10a512930 of class __NSArrayI autoreleased with no pool in place - just leaking - break on objc_autoreleaseNoPool() to debug 2012-09-28 18:07:39.042 ClassMethod[84934:403] ( ) +[MainClass load]
其原因是runtime调用+(void)load的时候，程序还没有建立其autorelease pool，所以那些会需要使用到autorelease pool的代码，都会出现异常。这一点是非常需要注意的，也就是说放在+(void)load中的对象都应该是alloc出来并且不能使用autorelease来释放。

9、load方法调用的顺序：父类(Superclass)的方法优先于子类(Subclass)的方法，类中的方法优先于类别(Category)中的方法。

10、所有类别(Category)中的load方法都会执行。

11、最后一个类别(Category)中的initialize方法会覆盖之前类别和类中的initialize方法。

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航