iOS-类/对象的两个面试题分析

面试题1：关于方法查找

定义一个类，该类包含两个方法-(void)sayHello;和+ (void)sayHappy;
代码如下：

@interface WPerson : NSObject

-(void)sayHello;
+ (void)sayHappy;
@end

问题1：请分析以下方法的打印结果

void lgInstanceMethod_classToMetaclass(Class pClass){
    
    const char *className = class_getName(pClass);
    Class metaClass = objc_getMetaClass(className);
    
    Method method1 = class_getInstanceMethod(pClass, @selector(sayHello));
    Method method2 = class_getInstanceMethod(metaClass, @selector(sayHello));

    Method method3 = class_getInstanceMethod(pClass, @selector(sayHappy));
    Method method4 = class_getInstanceMethod(metaClass, @selector(sayHappy));
    
    WLog(@"%s: %p - %p - %p - %p",__func__,method1,method2,method3,method4);
}

分析：

objc_getMetaClass获取该类的元类，返回元类的地址
class_getInstanceMethod获取类的实例方法，如果实例方法不存在则返回null

method1：获取WPerson类的sayHello方法，由于sayHello本身就是实例方法，所以method1不为空
method2：获取WPerson元类的sayHello方法，由于sayHello方法不存在于元类中，所以method2为空
method3：获取WPerson类的sayHappy方法，由于sayHappy本身就是类方法，并不是实例方法，所以method3返回空
method4：获取WPerson元类的sayHappy方法，由于sayHappy本身是类方法，类方法存储在元类中并已实例方法的方式呈现，所以method4不为空

我们来看打印结果：

lgInstanceMethod_classToMetaclass: 0x100003140 - 0x0 - 0x0 - 0x1000030c0

问题2：请分析以下方法的打印结果

void lgClassMethod_classToMetaclass(Class pClass){
    
    const char *className = class_getName(pClass);
    Class metaClass = objc_getMetaClass(className);
    
    Method method1 = class_getClassMethod(pClass, @selector(sayHello));
    Method method2 = class_getClassMethod(metaClass, @selector(sayHello));

    Method method3 = class_getClassMethod(pClass, @selector(sayHappy));
    Method method4 = class_getClassMethod(metaClass, @selector(sayHappy));
    
    WLog(@"%s: %p - %p - %p - %p",__func__,method1,method2,method3,method4);
}

class_getClassMethod获取类的类方法，如果不存在，则返回null

分析：

method1：获取WPerson类的sayHello方法，由于sayHello本身就是实例方法，所以method1为空
method2：获取WPerson元类的sayHello方法，由于sayHello方法不存在于元类中，所以method2为空
method3：获取WPerson类的sayHappy方法，由于sayHappy本身是类方法，所以method3不为空
method4：获取WPerson元类的sayHappy方法，由于sayHappy本身是类方法，我们通过上个例子知道了类方法在元类中是以实例方法呈现，按道理说这里method4应该返回空，但是结果并不是这样，我们看结果：
```
lgClassMethod_classToMetaclass: 0x0 - 0x0 - 0x1000020c0 - 0x1000020c0
```
method4结果并不为空，这是为什么呢？
要该清楚这个问题，我们就要去查看class_getClassMethod方法的源码实现
下面是源码：
```
/***********************************************************************
* class_getClassMethod.  Return the class method for the specified
* class and selector.
**********************************************************************/
Method class_getClassMethod(Class cls, SEL sel)
{
    if (!cls  ||  !sel) return nil;

    return class_getInstanceMethod(cls->getMeta(), sel);
}
```
我们看到这个方法实际上是调用的获取类的实例方法，参数传递是该类的元类，我们再查看getMeta()方法的源码
```
Class getMeta() {
        if (isMetaClass()) return (Class)this;
        else return this->ISA();
 }
```
通过getMeta源码我们发现，如果当前class已经是元类，则直接返回当前类的指针，否则返回当前类的ISA，class_getClassMethod实际调用流程如下图：

流程图

所以method4实际上是返回的WPerson元类的实例方法sayHappy，所以method4并不为空

面试题2：`isKindOfClass`和`isMemberOfClass`

分析下面代码的输出：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        BOOL re1 = [(id)[NSObject class] isKindOfClass:[NSObject class]];       
        BOOL re2 = [(id)[NSObject class] isMemberOfClass:[NSObject class]];
        BOOL re3 = [(id)[WPerson class] isKindOfClass:[WPerson class]];
        BOOL re4 = [(id)[WPerson class] isMemberOfClass:[WPerson class]];
        NSLog(@"\n re1 :%hhd\n re2 :%hhd\n re3 :%hhd\n re4 :%hhd\n",re1,re2,re3,re4);

        BOOL re5 = [(id)[NSObject alloc] isKindOfClass:[NSObject class]];
        BOOL re6 = [(id)[NSObject alloc] isMemberOfClass:[NSObject class]];
        BOOL re7 = [(id)[WPerson alloc] isKindOfClass:[WPerson class]];
        BOOL re8 = [(id)[WPerson alloc] isMemberOfClass:[WPerson class]];
        NSLog(@"\n re5 :%hhd\n re6 :%hhd\n re7 :%hhd\n re8 :%hhd\n",re5,re6,re7,re8);
    }
    return 0;
}

+ (BOOL)isKindOfClass

我们先找到源码：

+ (BOOL)isKindOfClass:(Class)cls {
    
    for (Class tcls = self->ISA(); tcls; tcls = tcls->superclass) {
        if (tcls == cls) return YES;
    }
    return NO;
}

如果你调试过此处的源码，你会发现最终的代码并不会运行到此处，这是因为在编译时系统经过编译优化，所以最终会运行到objc_opt_isKindOfClass方法

BOOL objc_opt_isKindOfClass(id obj, Class otherClass)

先上源码：

// Calls [obj isKindOfClass]
BOOL
objc_opt_isKindOfClass(id obj, Class otherClass)
{
#if __OBJC2__
    if (slowpath(!obj)) return NO;
    Class cls = obj->getIsa();
    if (fastpath(!cls->hasCustomCore())) {
        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);
}

通过源码分析我们知道，

如果调用者obj是对象，那么最终会获取该对象的isa然后走该对象的类的继承链进行查找判断
如果调用者obj是类类型，我们知道类的isa指向该类的元类，所以这时会走元类的继承链条进行查找判断

isMemberOfClass

这个方法的源码比较简单，如下

+ (BOOL)isMemberOfClass:(Class)cls {
    return self->ISA() == cls;
}

- (BOOL)isMemberOfClass:(Class)cls {
    return [self class] == cls;
}

我相信各位都能理解

面试题2结果分析

先上一个isa的流程图

isa流程图

类调用：

re1：这里判断是NSObject类是否是NSObject类型，通过objc_opt_isKindOfClass源码我们知道，这会走元类的继承链条，NSObject的元类根元类，NSObject != 根元类，继续查找，根元类继承自NSObject，NSObject == NSObject，所以re1 = 1
re2：NSObject->ISA()返回根元类，根元类 != NSObject，所以re2 = 0
re3：WPerson->getIsa()返回WPerson元类，元类和类继承链上的任一子类都不会相等，所以re3 = 0
re4：WPerson->ISA()返回WPerson元类，元类和WPerson类不相等，所以re4 = 0

对象调用：

re5: NSObject对象->getIsa()返回NSObject类，NSObject == NSObject，所以re5 = 1
re6: NSObject对象->ISA()返回NSObject类，NSObject == NSObject，所以re6 = 1
re7: WPerson对象->getIsa()返回WPerson类，WPerson == WPerson，所以re7 = 1
re8: WPerson对象->ISA()返回WPerson类，WPerson == WPerson，所以re8 = 1

运行结果输出：

 re1 :1
 re2 :0
 re3 :0
 re4 :0
 re5 :1
 re6 :1
 re7 :1
 re8 :1

Perfect，完美！