`
啸笑天
  • 浏览: 3472124 次
  • 性别: Icon_minigender_1
  • 来自: China
社区版块
存档分类
最新评论

Objective-C 中 +load 与 +initialize

 
阅读更多

 

类的加载

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

 

public class MyClass{  
    static{  
        ……  
    }  
}

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

比如：

 

#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的顺序

 

#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       // 
LOAD            //3  
+ (void)hello  
{  
    NSLog(@"Hello");  
}  
+ (void)hi  
{  
    NSLog(@"hi");  
}  
@end  

@interface C2 (Hello)  
@end  
@implementation C2 (Hello)  
+ (void)load    //4 
{  
    NSLog(@"%s", __PRETTY_FUNCTION__);  
}  

+ (void)initialize    // 
{  
    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:47:07.859 www[654:903] +[C1 load]

2012-08-1400:47:07.862 www[654:903] +[C2 load]

2012-08-14 00:47:07.863 www[654:903] +[C1(Hello) load]

2012-08-14 00:47:07.863 www[654:903] +[C2(Hello) load]

以上只执行了load方法。

 

 

load和initialize的顺序：

 

#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]

 

 

 

再看下面代码：

 

#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调用父类的方法。

2、load和initialize被调用一次是相对runtime而言 ，你可以当作普通类方法多次调用。

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

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

 

+(void)initialize{
if(self == [XXXClass clasee])
//todo
}
 加了这个检测后，只会在期望的那个类被加载的时候执行。

 

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

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

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

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

 

@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方法。

 

 

 

 

 

分享到：
| iOS-在objc项目中使用常量的最佳实践
评论
6 楼 啸笑天 2015-05-04  
http://www.cnblogs.com/ider/archive/2012/10/26/objective-c-initialize-static-variable.html
5 楼 啸笑天 2015-05-04  
+(void)initialize和+(void)load，我们并不需要在这两个方法的实现中使用super调用父类的方法
4 楼 啸笑天 2015-05-04  
不需要显示使用super调用父类中的方法
3 楼 啸笑天 2015-05-04  
A class’s +load method is called after all of its superclasses’ +load methods.
A category +load method is called after the class’s own +load method.
2 楼 啸笑天 2014-11-26  
http://www.cnblogs.com/ider/archive/2012/09/29/objective_c_load_vs_initialize.html
1 楼 dd916 2014-10-14  
你好，想问一下，iOS中单例模式的 饿汉型 是不是可以用load来实现呢？
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    objective-c 程序设计 ＋ 代码

    1. **类与对象**：Objective-C中的所有事物都是对象，它们由类定义。类是一个蓝图，描述了对象的行为和属性。你可以通过`@interface`声明类，`@implementation`实现类。 2. **消息传递**：Objective-C使用消息传递...

    +load 和 +initialize

    在Objective-C（简称OC）编程语言中，`+load`和`+initialize`是两个非常重要的类方法，它们在程序运行期间起到了初始化类的作用。理解并恰当使用这两个方法，能够帮助开发者更好地控制类的加载和初始化时机，实现...

    The Objective-C 2.0 Programming Language

    4. 对象初始化和析构：Objective-C 2.0改进了对象初始化过程，引入了`-init`方法的快速失败机制，以及`+load`和`+initialize`方法，用于类加载时的自定义行为。 三、内存管理与ARC Objective-C 2.0引入了自动引用...

    load,initialize测试代码

    在iOS和Objective-C（OC）开发中，"load"和"initialize"是两个重要的类方法，它们在程序启动时被自动调用，用于执行一些初始化操作。了解并正确使用这两个方法对于优化应用性能和实现优雅的初始化逻辑至关重要。 ...

    IOS -（void）load 方法的响应

    在iOS开发中，`-(void)load`方法是Objective-C中的一个特殊方法，它与类的加载和初始化过程紧密相关。这个方法在类或者category被加载到内存时会被自动调用，无需显式调用。了解`load`方法的工作原理和应用场景对于...

    Object-C学习大纲.pdf

    - **兼容性**：完全兼容 C 语言，这意味着可以在 Objective-C 代码中混入 C 语言甚至 C++ 代码。 #### 二、开发环境配置 - **操作系统**：Mac OS。 - **IDE**：Xcode。 - **创建项目**： - 选择 Mac OS 下的 ...

    面试题整理(优化后，需要持续优化)1

    - 使用`+load`方法可以在类加载时执行代码，`+initialize`则在类首次使用时执行。 - `KVO`通过替换对象的`isa`指针来实现观察，`KVC`通过消息发送找到属性并设置值。 - `NSNotification`是发布/订阅模型，用于对象间...

    SwiftLoadHook:使用hack方法来实现与OC中的Load（）或initialize（）类似的功能

    方法'initialize（）'定义了Objective-C类的方法'initialize'，它不能保证由Swift调用，并且在以后的版本中将不允许使用。 要求 iOS 8.0以上 迅捷3.0+ 用法 首先，将Sources文件夹下的文件拖放到您的项目中。 然后...

    OC语法底层原理精简版.pdf

    Objective-C是一种基于C语言的面向对象编程语言，其语法底层原理是C和C++的数据结构实现的。在iOS开发中，Objective-C是主要的编程语言，对于深入理解OC语法底层原理，有助于提升代码效率和优化。 首先，让我们来...

    OC底层原理之OC语法

    Objective-C（简称OC）是苹果公司开发的面向对象的编程语言，它是基于C语言的扩展。在iOS和Mac OS X的开发中，深入理解OC的底层原理对于优化代码和提升性能至关重要。以下将对描述中的关键概念进行详细解释。 1. **...

    OC底层原理之OC语法课件ppt

    ### OC底层原理详解 #### 一、Objective-C (OC) 对象的本质 Objective-C是一种面向对象的编程语言，它在C的基础上...以上内容涵盖了Objective-C中的一些核心概念和技术细节，对于深入理解和掌握Objective-C非常关键。

    CategoriesObjC：可可类的通用类别

    在Objective-C编程中，"Categories"是一种强大的工具，它允许开发者扩展已有类的功能而不必创建子类。"CategoriesObjC"项目就是一个集中展示Objective-C类别用法的例子，它提供了对苹果的Cocoa框架中多种类的通用...

    关于一些 iOS 面试问题的解答1

    它在Objective-C和Swift中自动跟踪并管理应用程序的内存使用，允许开发者不再手动调用`retain`和`release`方法。这样做的好处是可以降低程序崩溃和内存泄漏的风险，减轻开发者的负担，并提高程序的性能和可预测性。...

    Runtime 动态添加方法(2).zip

    在iOS和macOS开发中，Objective-C（简称OC）是一种强大的面向对象的编程语言，它在Apple的开发环境中被广泛使用。"Runtime 动态添加方法(2)"这个主题主要聚焦于Objective-C运行时系统的一个核心特性：动态方法解析。...

    30道 iOS底层面试题（上）

    与+initialize不同，load方法的调用顺序是确定的。 13. **App启动流程**：App启动时会经历main函数、UIApplicationMain、AppDelegate的生命周期方法等一系列过程。理解这个流程有助于优化启动速度和处理启动时的...

    iOS9-Runtime-Headers:iOS 9 测试版 1

    例如，`NSObject`是所有Objective-C类的基类，它的`+load`和`+initialize`方法在类加载时被调用，可以用来实现类级别的初始化逻辑。`NSMethodSignature`对象描述了一个方法的参数和返回值类型，而`NSInvocation`则...

    用objc/runtime给类别扩展属性代码

    在iOS开发中，Objective-C runtime 是一个非常强大的工具，它允许我们在运行时动态地修改类的行为，添加属性、方法等。本篇文章将深入探讨如何利用objc/runtime为类别扩展属性的代码实现。 首先，我们需要理解...

    DYCategory-Additions

    这类扩展通常被称为Category，在Objective-C中，Category允许我们在不修改原有类源代码的情况下，为其添加新的方法或者重定义已有的方法，极大地增强了类的可扩展性。 Objective-C的Category主要有以下几个核心知识...

    ios-iOS类目常用类目.zip

    3. 对于分类中的+load和+initialize方法，如果多个分类中都有定义，那么执行顺序是不确定的，因此不建议在分类中使用这两个方法。 4. 如果需要在类目中添加属性，需要使用关联对象（Associated Objects）来实现。 ...

Magicbox
Global site tag (gtag.js) - Google Analytics