本文將對category的原始碼進行比較全面的整理分析，最後結合一些面試題進行總結，希望對讀者有所裨益。
GitHub Repo：iOSDeepAnalyse
Follow: MisterBooo · GitHub
Source: Category：從底層原理研究到面試題分析
公眾號：五分鐘學演算法
目錄
- 1.Category原始碼分析
- 2.load原始碼分析
- 3.initialize原始碼分析
- 4.load與initialize對比
- 5.面試題分析
原始碼分析
1.原始碼閱讀前的準備
本節程式碼基於以下的程式碼進行編譯研究：
@interface Person : NSObject
- (void)instanceRun;
+ (void)methodRun;
@property(nonatomic, copy) NSString *name;
@end
複製程式碼@interface Person (Eat)
@property(nonatomic, assign) int age;
- (void)instanceEat;
+ (void)methodEat;
@end
複製程式碼@interface Person (Drink)
- (void)instanceEat;
@property(nonatomic, copy) NSString *waters;
@end
複製程式碼2.objc4中的原始碼
通過objc4中的原始碼進行分析，可以在objc-runtime-new.h中找到Category的結構如下
struct category_t {
const char *name;
classref_t cls;
struct method_list_t *instanceMethods;
struct method_list_t *classMethods;
struct protocol_list_t *protocols;
struct property_list_t *instanceProperties;
// Fields below this point are not always present on disk.
struct property_list_t *_classProperties;
method_list_t *methodsForMeta(bool isMeta) {
if (isMeta) return classMethods;
else return instanceMethods;
}
property_list_t *propertiesForMeta(bool isMeta, struct header_info *hi);
};
複製程式碼不難發現在這個結構體重儲存著物件方法、類方法、協議和屬性。接下來我們來驗證一下我們剛剛自己編寫的Person+Eat.m這個分類在編譯時是否是這種結構。
通過
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc Person+Eat.m
命令將Person+Eat.m檔案編譯成cpp檔案，以下的原始碼分析基於Person+Eat.cpp裡面的程式碼。下面讓我們開始窺探Category的底層結構吧~
2.Person+Eat.cpp原始碼
將Person+Eat.cpp的程式碼滑到底部部分，可以看見一個名為_category_t的結構體，這就是Category的底層結構
struct _category_t {
const char *name;
struct _class_t *cls;
const struct _method_list_t *instance_methods; // 物件方法列表
const struct _method_list_t *class_methods;// 類方法列表
const struct _protocol_list_t *protocols;// 協議列表
const struct _prop_list_t *properties;// 屬性列表
};
複製程式碼Person+Eat.m這個分類的結構也是符合_category_t這種形式的
static struct _category_t _OBJC_$_CATEGORY_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) =
{
"Person",
0, // &OBJC_CLASS_$_Person,
(const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Eat, // 物件方法列表
(const struct _method_list_t *)&_OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Eat,// 類方法列表
(const struct _protocol_list_t *)&_OBJC_CATEGORY_PROTOCOLS_$_Person_$_Eat, // 協議列表
(const struct _prop_list_t *)&_OBJC_$_PROP_LIST_Person_$_Eat, // 屬性列表
};
複製程式碼我們開始來分析上面這個結構體的內部成員，其中Person表示類名
物件方法列表
_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Eat是物件方法列表，在Person+Eat.cpp檔案中可以找到_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Eat具體描述
_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_objc_method),
1,
{{(struct objc_selector *)"instanceEat", "v16@0:8", (void *)_I_Person_Eat_instanceEat}}
};
複製程式碼instanceEat就是我們上述實現的Person+Eat分類裡面的例項方法。
類方法列表
_OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Eat是類方法列表，在Person+Eat.cpp中具體描述如下
_OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_objc_method),
1,
{{(struct objc_selector *)"classEat", "v16@0:8", (void *)_C_Person_Eat_classEat}}
};
複製程式碼協議列表
_OBJC_CATEGORY_PROTOCOLS_$_Person_$_Eat是協議列表，在Person+Eat.cpp中具體描述如下
_OBJC_CATEGORY_PROTOCOLS_$_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {
2,
&_OBJC_PROTOCOL_NSCopying,
&_OBJC_PROTOCOL_NSCoding
};
複製程式碼屬性列表
_OBJC_$_PROP_LIST_Person_$_Eat是屬性列表，在Person+Eat.cpp中具體描述如下
_OBJC_$_PROP_LIST_Person_$_Eat __attribute__ ((used, section ("__DATA,__objc_const"))) = {
sizeof(_prop_t),
2,
{{"weight","Ti,N"},
{"height","Ti,N"}}
};
複製程式碼3.Category的載入處理過程
通過上面的分析，我們驗證了編寫一個分類的時候，在編譯期間，這個分類內部的確會有category_t這種資料結構，那麼這種資料結構是如何作用到這個類的呢？分類的方法和類的方法呼叫的邏輯是怎麼樣的呢？我們接下來回到objc4原始碼中進一步分析Category的載入處理過程來揭曉Category的神祕面紗。
我們按照如下函式的呼叫順序，一步一步的研究Category的載入處理過程
void _objc_init(void);
└── void map_images(...);
└── void map_images_nolock(...);
└── void _read_images(...);
└── void _read_images(...);
└── static void remethodizeClass(Class cls);
└──attachCategories(Class cls, category_list *cats, bool flush_caches);
複製程式碼| 檔名 | 方法 |
|---|---|
| objc-os.mm | _objc_init |
| objc-os.mm | map_images |
| objc-os.mm | map_images_nolock |
| objc-runtime-new.mm | _read_images |
| objc-runtime-new.mm | remethodizeClass |
| objc-runtime-new.mm | attachCategories |
| objc-runtime-new.mm | attachLists |
在iOS 程式 main 函式之前發生了什麼
中提到，_objc_init這個函式是runtime的初始化函式，那我們從_objc_init這個函式開始進行分析。
/***********************************************************************
* _objc_init
* Bootstrap initialization. Registers our image notifier with dyld.
* Called by libSystem BEFORE library initialization time
**********************************************************************/
void _objc_init(void)
{
static bool initialized = false;
if (initialized) return;
initialized = true;
// fixme defer initialization until an objc-using image is found?
environ_init();
tls_init();
static_init();
lock_init();
exception_init();
_dyld_objc_notify_register(&map_images, load_images, unmap_image);
}
複製程式碼接著我們來到 &map_images讀取資源（images這裡代表資源模組），來到map_images_nolock函式中找到_read_images函式，在_read_images函式中我們找到與分類相關的程式碼
// Discover categories.
for (EACH_HEADER) {
category_t **catlist =
_getObjc2CategoryList(hi, &count);
bool hasClassProperties = hi->info()->hasCategoryClassProperties();
for (i = 0; i < count; i++) {
category_t *cat = catlist[i];
Class cls = remapClass(cat->cls);
if (!cls) {
catlist[i] = nil;
if (PrintConnecting) {
_objc_inform("CLASS: IGNORING category \?\?\?(%s) %p with "
"missing weak-linked target class",
cat->name, cat);
}
continue;
}
bool classExists = NO;
if (cat->instanceMethods || cat->protocols
|| cat->instanceProperties)
{
addUnattachedCategoryForClass(cat, cls, hi);
if (cls->isRealized()) {
remethodizeClass(cls);
classExists = YES;
}
if (PrintConnecting) {
_objc_inform("CLASS: found category -%s(%s) %s",
cls->nameForLogging(), cat->name,
classExists ? "on existing class" : "");
}
}
if (cat->classMethods || cat->protocols
|| (hasClassProperties && cat->_classProperties))
{
addUnattachedCategoryForClass(cat, cls->ISA(), hi);
if (cls->ISA()->isRealized()) {
remethodizeClass(cls->ISA());
}
if (PrintConnecting) {
_objc_inform("CLASS: found category +%s(%s)",
cls->nameForLogging(), cat->name);
}
}
}
}
複製程式碼在上面的程式碼中，主要做了以下的事情
- 1.獲取
category列表list - 2.遍歷
category list中的每一個category - 3.獲取
category的cls，如果沒有cls，則跳過(continue)這個繼續獲取下一個 - 4.如果
cat有例項方法、協議、屬性，則呼叫addUnattachedCategoryForClass，同時如果cls有實現的話，就進一步呼叫remethodizeClass方法 - 5.如果
cat有類方法、協議，則呼叫addUnattachedCategoryForClass，同時如果cls的元類有實現的話，就進一步呼叫remethodizeClass方法
其中4,5兩步的區別主要是cls是類物件還是元類物件的區別，我們接下來主要是看在第4步中的addUnattachedCategoryForClass和remethodizeClass方法。
addUnattachedCategoryForClass
static void addUnattachedCategoryForClass(category_t *cat, Class cls,
header_info *catHeader)
{
runtimeLock.assertWriting();
// DO NOT use cat->cls! cls may be cat->cls->isa instead
NXMapTable *cats = unattachedCategories();
category_list *list;
list = (category_list *)NXMapGet(cats, cls);
if (!list) {
list = (category_list *)
calloc(sizeof(*list) + sizeof(list->list[0]), 1);
} else {
list = (category_list *)
realloc(list, sizeof(*list) + sizeof(list->list[0]) * (list->count + 1));
}
list->list[list->count++] = (locstamped_category_t){cat, catHeader};
NXMapInsert(cats, cls, list);
}
static NXMapTable *unattachedCategories(void)
{
runtimeLock.assertWriting();
//全域性物件
static NXMapTable *category_map = nil;
if (category_map) return category_map;
// fixme initial map size
category_map = NXCreateMapTable(NXPtrValueMapPrototype, 16);
return category_map;
}
複製程式碼對上面的程式碼進行解讀：
- 1.通過
unattachedCategories()函式生成一個全域性物件cats - 2.我們從這個單例物件中查詢
cls，獲取一個category_list*list列表 - 3.要是沒有
list指標。那麼我們就生成一個category_list空間。 - 4.要是有
list指標，那麼就在該指標的基礎上再分配出category_list大小的空間 - 5.在這新分配好的空間，將這個
cat和catHeader寫入。 - 6.將資料插入到
cats中,key是cls, 值是list
remethodizeClass
static void remethodizeClass(Class cls)
{
//分類陣列
category_list *cats;
bool isMeta;
runtimeLock.assertWriting();
isMeta = cls->isMetaClass();
// Re-methodizing: check for more categories
if ((cats = unattachedCategoriesForClass(cls, false/*not realizing*/))) {
if (PrintConnecting) {
_objc_inform("CLASS: attaching categories to class '%s' %s",
cls->nameForLogging(), isMeta ? "(meta)" : "");
}
attachCategories(cls, cats, true /*flush caches*/);
free(cats);
}
}
複製程式碼在remethodizeClass函式中將通過attachCategories函式我們的分類資訊附加到該類中。
attachCategories
//cls = [Person class]
//cats = [category_t(Eat),category_t(Drink)]
static void
attachCategories(Class cls, category_list *cats, bool flush_caches)
{
if (!cats) return;
if (PrintReplacedMethods) printReplacements(cls, cats);
bool isMeta = cls->isMetaClass();
// 重新分配記憶體
method_list_t **mlists = (method_list_t **)
malloc(cats->count * sizeof(*mlists));
property_list_t **proplists = (property_list_t **)
malloc(cats->count * sizeof(*proplists));
protocol_list_t **protolists = (protocol_list_t **)
malloc(cats->count * sizeof(*protolists));
// Count backwards through cats to get newest categories first
int mcount = 0;
int propcount = 0;
int protocount = 0;
int i = cats->count;
bool fromBundle = NO;
while (i--) {
auto& entry = cats->list[i];
method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
if (mlist) {
mlists[mcount++] = mlist;
fromBundle |= entry.hi->isBundle();
}
property_list_t *proplist =
entry.cat->propertiesForMeta(isMeta, entry.hi);
if (proplist) {
proplists[propcount++] = proplist;
}
protocol_list_t *protolist = entry.cat->protocols;
if (protolist) {
protolists[protocount++] = protolist;
}
}
auto rw = cls->data();
prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
rw->methods.attachLists(mlists, mcount);
free(mlists);
if (flush_caches && mcount > 0) flushCaches(cls);
rw->properties.attachLists(proplists, propcount);
free(proplists);
rw->protocols.attachLists(protolists, protocount);
free(protolists);
}
複製程式碼對上面的程式碼進行解讀（假設cls是類物件，元類物件分析同理）：
-
1.根據方法列表、屬性列表、協議列表分配記憶體
-
2.
cats是這種資料結構：[category_t(Eat),category_t(Drink)，。。。]，遍歷cats，然後- 1.獲取一個分類裡面的所有物件方法，儲存在
mlist陣列中，然後再將mlist陣列新增到二維陣列mlists中 - 2.獲取一個分類裡面的所有協議，儲存在
proplist陣列中，然後再將proplist陣列新增到二維陣列proplists中 - 3.獲取一個分類裡面的所有屬性，儲存在
protolist陣列中，然後再將protolist陣列新增到二維陣列protolists中
- 1.獲取一個分類裡面的所有物件方法，儲存在
-
3.獲取
cls的的bits指標class_rw_t,通過attachLists方法，將mlists附加到類物件方法列表中，將proplists附加到類物件的屬性列表中，將protolists附加到類物件的協議列表中
其中mlists的資料結構如下,proplists與protolists同理：
[
[method_t,method_t],
[method_t,method_t]
]
複製程式碼attachLists
void attachLists(List* const * addedLists, uint32_t addedCount) {
if (addedCount == 0) return;
if (hasArray()) {
// many lists -> many lists
uint32_t oldCount = array()->count;
uint32_t newCount = oldCount + addedCount;
setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));
array()->count = newCount;
memmove(array()->lists + addedCount, array()->lists,
oldCount * sizeof(array()->lists[0]));
memcpy(array()->lists, addedLists,
addedCount * sizeof(array()->lists[0]));
}
else if (!list && addedCount == 1) {
// 0 lists -> 1 list
list = addedLists[0];
}
else {
// 1 list -> many lists
List* oldList = list;
uint32_t oldCount = oldList ? 1 : 0;
uint32_t newCount = oldCount + addedCount;
setArray((array_t *)malloc(array_t::byteSize(newCount)));
array()->count = newCount;
if (oldList) array()->lists[addedCount] = oldList;
memcpy(array()->lists, addedLists,
addedCount * sizeof(array()->lists[0]));
}
}
複製程式碼在attachLists方法主要關注兩個變數array()->lists和addedLists
- array()->lists： 類物件原來的方法列表，屬性列表，協議列表，比如Person中的那些方法等
- addedLists：傳入所有分類的方法列表，屬性列表，協議列表，比如Person(Eat)、Person(Drink)中的那些方法等。
上面程式碼的作用就是通過memmove將原來的類找那個的方法、屬性、協議列表分別進行後移，然後通過memcpy將傳入的方法、屬性、協議列表填充到開始的位置。
我們來總結一下這個過程：
-
通過Runtime載入某個類的所有Category資料
-
把所有Category的方法、屬性、協議資料，合併到一個大陣列中，後面參與編譯的Category資料，會在陣列的前面
-
將合併後的分類資料（方法、屬性、協議），插入到類原來資料的前面
我們可以用如下的動畫來表示一下這個過程（更多動畫相關可在公眾號內獲取）
- 1)、category的方法沒有“完全替換掉”原來類已經有的方法，也就是說如果category和原來類都有methodA，那麼category附加完成之後，類的方法列表裡會有兩個methodA.
- 2)、category的方法被放到了新方法列表的前面，而原來類的方法被放到了新方法列表的後面，這也就是我們平常所說的category的方法會“覆蓋”掉原來類的同名方法，這是因為執行時在查詢方法的時候是順著方法列表的順序查詢的，它只要一找到對應名字的方法，就會罷休^_^，殊不知後面可能還有一樣名字的方法。
我們通過程式碼來驗證一下上面兩個注意點是否正確
load與initialize
load方法與initialize方法的呼叫與一般普通方法的呼叫有所區別，因此筆者將其放在這一節一併分析進行想對比
load原始碼分析
同樣的，我們按照如下函式的呼叫順序，一步一步的研究load的載入處理過程
void _objc_init(void);
└── void load_images(...);
└── void call_load_methods(...);
└── void call_class_loads(...);
複製程式碼我們直接從load_images方法進行分析
void
load_images(const char *path __unused, const struct mach_header *mh)
{
// Return without taking locks if there are no +load methods here.
if (!hasLoadMethods((const headerType *)mh)) return;
recursive_mutex_locker_t lock(loadMethodLock);
// Discover load methods
{
rwlock_writer_t lock2(runtimeLock);
prepare_load_methods((const headerType *)mh);
}
// Call +load methods (without runtimeLock - re-entrant)
call_load_methods();
}
複製程式碼在load_images方法中主要關注prepare_load_methods方法與call_load_methods方法
prepare_load_methods
void prepare_load_methods(header_info *hi)
{
size_t count, i;
rwlock_assert_writing(&runtimeLock);
classref_t *classlist =
_getObjc2NonlazyClassList(hi, &count);
for (i = 0; i < count; i++) {
schedule_class_load(remapClass(classlist[i]));
}
category_t **categorylist = _getObjc2NonlazyCategoryList(hi, &count);
for (i = 0; i < count; i++) {
category_t *cat = categorylist[i];
Class cls = remapClass(cat->cls);
if (!cls) continue; // category for ignored weak-linked class
realizeClass(cls);
assert(cls->ISA()->isRealized());
add_category_to_loadable_list(cat);
}
}
複製程式碼static void schedule_class_load(Class cls)
{
if (!cls) return;
assert(cls->isRealized()); // _read_images should realize
if (cls->data()->flags & RW_LOADED) return;
// 確保父類優先的順序
schedule_class_load(cls->superclass);
add_class_to_loadable_list(cls);
cls->setInfo(RW_LOADED);
}
複製程式碼顧名思義，這個函式的作用就是提前準備好滿足 +load 方法呼叫條件的類和分類，以供接下來的呼叫。
然後在這個類中呼叫了schedule_class_load(Class cls)方法，並且在入參時對父類遞迴的呼叫了，確保父類優先的順序。
call_load_methods
經過prepare_load_methods的準備，接下來call_load_methods就開始大顯身手了。
void call_load_methods(void)
{
static BOOL loading = NO;
BOOL more_categories;
recursive_mutex_assert_locked(&loadMethodLock);
// Re-entrant calls do nothing; the outermost call will finish the job.
if (loading) return;
loading = YES;
void *pool = objc_autoreleasePoolPush();
do {
// 1. Repeatedly call class +loads until there aren't any more
while (loadable_classes_used > 0) {
call_class_loads();
}
// 2. Call category +loads ONCE
more_categories = call_category_loads();
// 3. Run more +loads if there are classes OR more untried categories
} while (loadable_classes_used > 0 || more_categories);
objc_autoreleasePoolPop(pool);
loading = NO;
}
複製程式碼在call_load_methods中我們看do迴圈這個方法，它呼叫上一步準備好的類和分類中的 +load 方法，並且確保類優先於分類的順序。
call_class_loads
call_class_loads是load方法呼叫的核心方法
static void call_class_loads(void)
{
int i;
// Detach current loadable list.
struct loadable_class *classes = loadable_classes;
int used = loadable_classes_used;
loadable_classes = nil;
loadable_classes_allocated = 0;
loadable_classes_used = 0;
// Call all +loads for the detached list.
for (i = 0; i < used; i++) {
Class cls = classes[i].cls;
load_method_t load_method = (load_method_t)classes[i].method;
if (!cls) continue;
if (PrintLoading) {
_objc_inform("LOAD: +[%s load]\n", cls->nameForLogging());
}
(*load_method)(cls, SEL_load);
}
// Destroy the detached list.
if (classes) _free_internal(classes);
}
複製程式碼這個函式的作用就是真正負責呼叫類的 +load 方法了。它從全域性變數 loadable_classes 中取出所有可供呼叫的類，並進行清零操作。
loadable_classes = nil;
loadable_classes_allocated = 0;
loadable_classes_used = 0;
複製程式碼其中 loadable_classes 指向用於儲存類資訊的記憶體的首地址，loadable_classes_allocated 標識已分配的記憶體空間大小，loadable_classes_used 則標識已使用的記憶體空間大小。
然後，迴圈呼叫所有類的 +load 方法。注意，這裡是（呼叫分類的 +load 方法也是如此）直接使用函式記憶體地址的方式 (*load_method)(cls, SEL_load); 對 +load 方法進行呼叫的，而不是使用傳送訊息 objc_msgSend 的方式。
但是如果我們寫[Student load]時，這是使用傳送訊息 objc_msgSend 的方式。
舉個?：
@interface Person : NSObject
@end
@implementation Person
+ (void)load{
NSLog(@"%s",__func__);
}
@end
複製程式碼@interface Student : Person
@end
@implementation Student
//+ (void)load{
// NSLog(@"%s",__func__);
//}
@end
複製程式碼int main(int argc, const char * argv[]) {
@autoreleasepool {
[Student load];
}
return 0;
}
複製程式碼輸出如下：
第一句走的是load的載入方式，而第二句走的是objc_msgSend中訊息傳送機制，isa指標通過superclass在父類中找到類方法。
小總結：
+load方法會在runtime載入類、分類時呼叫- 每個類、分類的+load，在程式執行過程中只呼叫一次
- 呼叫順序
1.先呼叫類的+load
按照編譯先後順序呼叫（先編譯，先呼叫）
呼叫子類的+load之前會先呼叫父類的+load
2.再呼叫分類的+load
按照編譯先後順序呼叫（先編譯，先呼叫）
initialize原始碼分析
同樣的，我們按照如下函式的呼叫順序，一步一步的研究initialize的載入處理過程
Method class_getInstanceMethod(Class cls, SEL sel);
└── IMP lookUpImpOrNil(Class cls, SEL sel, id inst, bool initialize, bool cache, bool resolver);
└── IMP lookUpImpOrForward(Class cls, SEL sel, id inst, bool initialize, bool cache, bool resolver);
└── void _class_initialize(Class cls);
└── void callInitialize(Class cls);
複製程式碼我們直接開啟objc-runtime-new.mm檔案來研究lookUpImpOrForward這個方法
lookUpImpOrForward
IMP lookUpImpOrForward(Class cls, SEL sel, id inst,
bool initialize, bool cache, bool resolver)
{
...
rwlock_unlock_write(&runtimeLock);
}
if (initialize && !cls->isInitialized()) {
_class_initialize (_class_getNonMetaClass(cls, inst));
// If sel == initialize, _class_initialize will send +initialize and
// then the messenger will send +initialize again after this
// procedure finishes. Of course, if this is not being called
// from the messenger then it won't happen. 2778172
}
// The lock is held to make method-lookup + cache-fill atomic
// with respect to method addition. Otherwise, a category could
...
}
複製程式碼initialize && !cls->isInitialized()判斷程式碼表明當一個類需要初始化卻沒有初始化時，會呼叫_class_initialize進行初始化。
_class_initialize
void _class_initialize(Class cls)
{
...
Class supercls;
BOOL reallyInitialize = NO;
// Make sure super is done initializing BEFORE beginning to initialize cls.
// See note about deadlock above.
supercls = cls->superclass;
if (supercls && !supercls->isInitialized()) {
_class_initialize(supercls);
}
...
callInitialize(cls);
...
}
複製程式碼同樣的supercls && !supercls->isInitialized()表明對入參的父類進行了遞迴呼叫，以確保父類優先於子類初始化。
callInitialize
void callInitialize(Class cls)
{
((void(*)(Class, SEL))objc_msgSend)(cls, SEL_initialize);
asm("");
}
複製程式碼最後在callInitialize中通過傳送訊息 objc_msgSend 的方式對 +initialize方法進行呼叫,也就是說+ initialize與一般普通方法的呼叫處理是一樣的。
舉個?：
@interface Person : NSObject
@end
@implementation Person
+ (void)initialize{
NSLog(@"%s",__func__);
}
@end
@implementation Person (Eat)
+ (void)initialize{
NSLog(@"%s",__func__);
}
@end
複製程式碼@interface Student : Person
@end
@implementation Student
+ (void)initialize{
NSLog(@"%s",__func__);
}
@end
複製程式碼@interface Teacher : Person
@end
@implementation Teacher
@end
複製程式碼int main(int argc, const char * argv[]) {
@autoreleasepool {
[Student alloc];
[Student initialize];
[Person alloc];
[Person alloc];
[Person alloc];
[Person alloc];
[Person alloc];
[Person alloc];
NSLog(@"****分割線***");
[Teacher alloc];
[Teacher initialize];
}
return 0;
}
複製程式碼輸出如下：
小總結：
+initialize方法會在類第一次接收到訊息時呼叫- 呼叫順序
- 先呼叫父類的+initialize，再呼叫子類的+initialize
- 先初始化父類，再初始化子類，每個類只會初始化1次
load與initialize對比
| 條件 | +load | +initialize |
|---|---|---|
| 關鍵方法 | (*load_method)(cls, SEL_load) |
objc_msgSend |
| 呼叫時機 | 被新增到 runtime 時 | 收到第一條訊息前，可能永遠不呼叫 |
| 呼叫順序 | 父類->子類->分類 | 父類->子類 |
| 呼叫次數 | 1次 | 多次 |
| 是否需要顯式呼叫父類實現 | 否 | 否 |
| 是否沿用父類的實現 | 否 | 是 |
| 分類中的實現 | 類和分類都執行 | 覆蓋類中的方法，只執行分類的實現 |
面試題
1.Category的使用場合是什麼？
-
- 給現有的類新增方法
-
- 將一個類的實現拆分成多個獨立的原始檔
-
- 宣告私有的方法
2.Category和Class Extension的區別是什麼？
-
- Class Extension是編譯時決議，在編譯的時候，它的資料就已經包含在類資訊中
-
- Category是執行時決議，在執行時，才會將資料合併到類資訊中（可通過上面的動畫進行理解
^_^）
- Category是執行時決議，在執行時，才會將資料合併到類資訊中（可通過上面的動畫進行理解
3.Category的實現原理？
-
- Category編譯之後的底層結構是
struct category_t，裡面儲存著分類的物件方法、類方法、屬性、協議資訊
- Category編譯之後的底層結構是
-
- 在程式執行的時候，runtime會將Category的資料，合併到類資訊中（類物件、元類物件中）(依舊可通過上面的動畫進行理解
-_-||）)
- 在程式執行的時候，runtime會將Category的資料，合併到類資訊中（類物件、元類物件中）(依舊可通過上面的動畫進行理解
4.一個類的有多個分類方法，分類中都含有與原類同名的方法，請問呼叫改方法時會呼叫誰的方法？分類會覆蓋原類的方法嗎？
不會覆蓋！所有分類的方法會在執行時將它們的方法都合併到一個大陣列中，後面參與編譯的Category資料，會在陣列的前面，然後再將該陣列合併到類資訊中，呼叫時順著方法列表的順序查詢。
5.load與initialize的區別
見load與initialize對比章節的表格
6.Category能否新增成員變數？如果可以，如何給Category新增成員變數？
不能直接給Category新增成員變數，但是可以通過關聯物件或者全域性字典等方式間接實現Category有成員變數的效果