主要内容：类相关的面试题
一、属性&成员变量&实例变量的区别？
二、为什么类和元类会有 类对象 的 类方法
三、isKindOfClass 和 isMemberOfClass 的区别
一、属性&成员变量&实例变量的区别？
-
属性：通过@property开头定义，带下划线成员变量+setter+getter方法的变量 -
成员变量：通过{}定义的， 且没有下划线的变量 -
实例变量: 通过当前对象类型进行与具备实例化的对象，例：NSObject, NSString，实例变量是特殊的成员变量（类的实例化）
二、class_getInstanceMethod 和 class_getClassMethod
面试题 问题：为什么 类和元类里 都有 sayHappy 类方法，类方法在元类中
- LGPerson 中定义实例方法ins_sayHello，类方法cls_sayHappy
@interface LGPerson : NSObject
- (void) ins_sayHello;
+ (void) cls_sayHappy;
@end
@implementation LGPerson
- (void)ins_sayHello{
NSLog(@"LGPerson say : Hello!!!");
}
+ (void)cls_sayHappy{
NSLog(@"LGPerson say : Happy!!!");
}
@end
- main函数，调用函数
int main(int argc, const char * argv[]) {
@autoreleasepool {
LGPerson *person = [LGPerson alloc];
Class pClass = object_getClass(person); // 等价于 Class pClass = [LGPerson class];
lgObjc_copyMethodList(pClass); // pClass 类对象
const char *className = class_getName(pClass);
Class pClassMate = objc_getMetaClass(className);
lgObjc_copyMethodList(pClassMate); // pClassMate是 LGPerson 的 元类
lgInstanceMethod_classToMetaclass(pClass);
lgClassMethod_classToMetaclass(pClass);
lgIMP_classToMetaclass(pClass);
}
return 0;
}
- lgObjc_copyMethodList 函数：用于获取类的实例方法列表
void lgObjc_copyMethodList(Class pClass){
unsigned int count = 0;
Method *methods = class_copyMethodList(pClass, &count);
for (unsigned int i=0; i < count; i++) {
Method const method = methods[I];
//获取方法名
NSString *key = NSStringFromSelector(method_getName(method));
LGLog(@"Method, name: %@", key);
}
free(methods);
}
其中 class_copyMethodList 的方法实现：
Method * class_copyMethodList(Class cls, unsigned int *outCount)
{
unsigned int count = 0;
Method *result = nil;
......
// cls->data() 得到 class_rw_t 类型数据
// class_rw_t -> methods() 获得方法，cls 是类对象就会获得实例方法，cls是元类就会获得类方法。
const auto methods = cls->data()->methods();
......
count = methods.count();
......
if (outCount) *outCount = count;
return result;
}
结论：
class_copyMethodList：参数cls是类对象就会获得实例方法，cls是元类就会获得类方法
lgObjc_copyMethodList(pClass);因为 pClass类对象，输出结果：ins_sayHello
lgObjc_copyMethodList(pClassMate); pClassMate是元类，输出结果：cls_sayHappy
- lgInstanceMethod_classToMetaclass 函数：用于获取类的实例方法
void lgInstanceMethod_classToMetaclass(Class pClass){
const char *className = class_getName(pClass);
Class metaClass = objc_getMetaClass(className);// 元类
// 类中获取实例方法ins_sayHello
Method method1 = class_getInstanceMethod(pClass, @selector(ins_sayHello));
// 元类中获取实例方法ins_sayHello
Method method2 = class_getInstanceMethod(metaClass, @selector(ins_sayHello));
// 类中获取类方法cls_sayHappy
Method method3 = class_getInstanceMethod(pClass, @selector(cls_sayHappy));
// 元类中获取类方法cls_sayHappy
Method method4 = class_getInstanceMethod(metaClass, @selector(cls_sayHappy));
LGLog(@"%s - %p-%p-%p-%p",__func__,method1,method2,method3,method4);
}
// 输出结果：lgInstanceMethod_classToMetaclass - 0x1000081b0-0x0-0x0-0x100008148
结论：
class_getInstanceMethod:如果在传入的类或者类的父类中没有找到指定的实例方法，则返回NULL
method1地址0x1000081b0：在LGPerson类对象中查找实例方法ins_sayHello，有这个实例方法，返回方法信息。
method2地址0x0：在LGPerson元类中查找实例方法ins_sayHello，查找顺序元类 --> 根元类 --> 根类 --> nil，直到最的没有找到，返回nil
method3地址0x0：在LGPerson类对象中查找实例方法cls_sayHappy，查找顺序LGPerson类 --> 根类 --> nil，直到最的没有找到，返回nil(cls_sayHappy 在 LGPerson中是以类方法的形式存放的)
method4地址0x100008148：在LGPerson元类中查找实例方法cls_sayHappy，有实例方法cls_sayHappy返回方法信息(类对象的类方法存储在元类中，类方法在元类中是以实例方法存放的)
- lgClassMethod_classToMetaclass 函数：用于获取类的类方法
void lgClassMethod_classToMetaclass(Class pClass){
const char *className = class_getName(pClass);
Class metaClass = objc_getMetaClass(className);
Method method1 = class_getClassMethod(pClass, @selector(ins_sayHello));
Method method2 = class_getClassMethod(metaClass, @selector(ins_sayHello));
Method method3 = class_getClassMethod(pClass, @selector(cls_sayHappy));
// 问题：元类 为什么有 sayHappy 类方法?
Method method4 = class_getClassMethod(metaClass, @selector(cls_sayHappy));
LGLog(@"%s-%p-%p-%p-%p",__func__,method1,method2,method3,method4);
}
// 输出结果：lgClassMethod_classToMetaclass-0x0-0x0-0x100008148-0x100008148
其中 方法实现
Method class_getClassMethod(Class cls, SEL sel)
{
if (!cls || !sel) return nil;
// 在元类中查找实现方法 sel
return class_getInstanceMethod(cls->getMeta(), sel);
}
Class getMeta() {
if (isMetaClass()) return (Class)this; // 如果是元类，原样返回
else return this->ISA(); // 返回 类的元类
}
结论：
class_getClassMethod：如果在传入的类或者类的父类中没有找到指定的类方法，则返回NULL
分析class_getClassMethod 和 getMeta的方法实现发现: 参数cls是LGPerson还是LGPerson的元类，其结果相同。
method1和method2地址0x0：在LGPerson类和LGPerson元类中查找类方法ins_sayHello-> 在LGPerson元类中查找实例方法ins_sayHello，没有找到，返回nil。
method3和method4地址0x100008148：在LGPerson类和LGPerson元类中查找类方法cls_sayHappy-> 在LGPerson元类中查找实例方法cls_sayHappy，找到了，返回方法信息。问题：
元类中为什么会有类方法cls_sayHappy方法？
主要还是因为class_getClassMethod方法在调用的getMeta方法获取元类，而getMeta方法中 优先判断是否是元类，如果是元类直接返回，没有再继续获取元类。因为元类继续找下去就会产生无限次递归，苹果为了防止无限次递归。
lgIMP_classToMetaclass函数：用于获取方法的实现
void lgIMP_classToMetaclass(Class pClass){
const char *className = class_getName(pClass);
Class metaClass = objc_getMetaClass(className);
// - (void)sayHello;
// + (void)sayHappy;
IMP imp1 = class_getMethodImplementation(pClass, @selector(ins_sayHello));
IMP imp2 = class_getMethodImplementation(metaClass, @selector(ins_sayHello));
IMP imp3 = class_getMethodImplementation(pClass, @selector(cls_sayHappy));
IMP imp4 = class_getMethodImplementation(metaClass, @selector(cls_sayHappy));
LGLog(@"%s-%p-%p-%p-%p",__func__,imp1,imp2,imp3,imp4);
}
//输出结果：lgIMP_classToMetaclass-0x100003d00-0x7fff68e08580-0x7fff68e08580-0x100003d30
class_getMethodImplementation 函数实现
IMP class_getMethodImplementation(Class cls, SEL sel)
{
IMP imp;
if (!cls || !sel) return nil;
//查找方法实现
imp = lookUpImpOrNil(nil, sel, cls, LOOKUP_INITIALIZE | LOOKUP_RESOLVER);
// 如果没有找到，则进行消息转发
if (!imp) {
return _objc_msgForward;
}
return imp;
}
结论：
class_getMethodImplementation：获取方法的具体实现，如果未查找到，则进行消息转发
分析方法实现：该函数在向类实例发送消息时会被调用，并返回一个指向方法实现函数的指针。这个函数会比method_getImplementation(class_getInstanceMethod(cls, name))更快。返回的函数指针可能是一个指向runtime内部的函数，而不一定是方法的实际实现。如果类实例无法响应selector，则返回的函数指针将是运行时消息转发机制的一部分
imp1 函数指针地址 0x100003d00：在
LGPerson中查找实例方法ins_sayHello的实现，存在，返回函数指针地址imp2 函数指针地址 0x7fff68e08580：在
LGPerson元类中查找实例方法ins_sayHello的实现，没有找到，进行消息转发imp3 函数指针地址 0x7fff68e08580：在
LGPerson中查找实例方法cls_sayHappy的实现，没有找到，进行消息转发imp4 函数指针地址 0x100003d30：在
LGPerson元类中查找实例方法cls_sayHappy的实现，存在，返回函数指针地址
总结
class_getInstanceMethod：获取实例方法，如果指定的类或其父类不包含带有指定选择器的实例方法，则为NULLclass_getClassMethod：获取类方法，如果指定的类或其父类不包含具有指定选择器的类方法，则为NULL。class_getMethodImplementation：获取方法的具体实现，如果未查找到，则进行消息转发
三、isKindOfClass 和 isMemberOfClass 的 类方法及实例方法的区别
- iskindOfClass & isMemberOfClass 类方法调用
BOOL re1 = [(id)[NSObject class] isKindOfClass:[NSObject class]];
BOOL re2 = [(id)[NSObject class] isMemberOfClass:[NSObject class]];
BOOL re3 = [(id)[LGPerson class] isKindOfClass:[LGPerson class]];
BOOL re4 = [(id)[LGPerson class] isMemberOfClass:[LGPerson class]];
NSLog(@" re1 :%hhd re2 :%hhd re3 :%hhd re4 :%hhd\n",re1,re2,re3,re4);
打印结果：re1 :1 re2 :0 re3 :0 re4 :0
- iskindOfClass & isMemberOfClass 实例方法调用
BOOL re5 = [(id)[NSObject alloc] isKindOfClass:[NSObject class]];
BOOL re6 = [(id)[NSObject alloc] isMemberOfClass:[NSObject class]];
BOOL re7 = [(id)[LGPerson alloc] isKindOfClass:[LGPerson class]];
BOOL re8 = [(id)[LGPerson alloc] isMemberOfClass:[LGPerson class]];
NSLog(@" re5 :%hhd re6 :%hhd re7 :%hhd re8 :%hhd\n",re5,re6,re7,re8);
打印结果：re5 :1 re6 :1 re7 :1 re8 :1
通过断点调试，发现isMemberOfClass的 类方法 和 实例方法 的流程是正确的，会走到相应的源码，而 isKindOfClass 不会进入 isKindOfClass 的源码，而是其类方法和实例方法都走到 objc_opt_isKindOfClass 方法源码中
汇编调试 发现 调用 objc_opt_isKindOfClass 方法(在
llvm中编译时对其进行了优化处理)- image.png
objc_opt_isKindOfClass方法的源码
BOOL objc_opt_isKindOfClass(id obj, Class otherClass)
{
#if __OBJC2__
if (slowpath(!obj)) return NO;
// 获取isa
// 如果obj 是对象，则 isa 是类； 如果obj是类 ，则 isa 是元类
Class cls = obj->getIsa();
if (fastpath(!cls->hasCustomCore())) {
// obj 是对象，则在类的继承链与指定类进行对比
// obj 是类， 则在元类的继承链与指定类进行对比
for (Class tcls = cls; tcls; tcls = tcls->superclass) {
if (tcls == otherClass) return YES;
}
return NO;
}
#endif
return ((BOOL(*)(id, SEL, Class))objc_msgSend)(obj, @selector(isKindOfClass:), otherClass);
}
// 类方法：获取类的元类，与传入的类对比
+ (BOOL)isMemberOfClass:(Class)cls {
return self->ISA() == cls;
}
//实例方法：获取对象的类，与传入的类对比
- (BOOL)isMemberOfClass:(Class)cls {
return [self class] == cls;
}
结论：
- objc_opt_isKindOfClass :
obj是类，获取类的元类，在元类的继承链与指定类进行对比
obj是对象，获取对象所属的类，在类的继承链与指定类进行对比- isMemberOfClass:
类方法：获取类的元类，与传入的类对比
实例方法：获取对象的类，与传入的类对比
类方法
- re1 :1
NSObject类isKindOfClassNSObject类
第一次：NSObject类的isa->NSObject的根元类与NSObject类对比 -- 不同等，继续
第二次：NSObject的根元类的superClass->NSObject类与NSObject类对比 -- 相等，返回1
- re2 :0
NSObject类isMemberOfClassNSObject类
NSObject类的isa->NSObject的根元类与NSObject类对比 -- 不同等，返回0
- re3 :0
LGPerson类isKindOfClassLGPerson类
第一次：LGPerson类的isa->LGPerson的元类与LGPerson类对比 -- 不同等，继续
第二次：LGPerson的元类的superClass->NSObject的根元类与LGPerson类对比 -- 不同等，继续
第三次：NSObject的根元类的superClass->NSObject类与LGPerson类对比 -- 不同等，继续
第四次：NSObject类的superClass->nil与LGPerson类对比 -- 不同等，返回0
- re4 :0
LGPerson类isMemberOfClassLGPersont类
LGPerson类的isa->LGPerson的元类与LGPersont类对比 -- 不同等，返回0
实例方法
- re5 :1
NSObject对象isKindOfClassNSObject类
第一次：NSObject对象的isa->NSObject类与NSObject类对比 -- 相等，返回1
- re6 :1
NSObject对象isMemberOfClassNSObject类
NSObject对象的class->NSObject的类与NSObject类对比 -- 相等，返回1
- re7 :1
LGPerson对象isKindOfClassLGPerson类
第一次：LGPerson对象的isa->LGPerson类与LGPerson类对比 -- 相等，返回1
- re8 :1
LGPerson对象isMemberOfClassLGPersont类
LGPerson对象的class->LGPerson的类与LGPersont类对比 -- 相等，返回1
