本文为大地瓜原创，欢迎知识共享，转载请注明出处。
虽然你不注明出处我也没什么精力和你计较。
作者微信号：christgreenlaw

方法（method）

Objective-C是C的扩展，在C的语言层面上加了一定的关键字和语法，其核心就是运行时、消息分发。
对于很多语言，编译器会执行优化和错误检查，因为调用关系很清楚。但是对于消息分发来说，事情就没那么简单了。发消息之前，你不用保证这个对象能够处理这个消息，发给这个对象消息后，对象可能会处理消息，也可能转发给其他的对象进行处理。消息和方法并不是一一对应关系，一个对象可以只用一个方法来处理多个消息。

在OC中，消息是通过objc_msgSend()这个runtime方法以及其他类似方法进行实现的。该方法需要target, selector以及一些必须的参数。理论上来说，编译器只是对发送消息进行了转化，将发送的消息变成objc_msgSend()来执行了。
可以大致理解成如下的代码：

[object doSomething: abc withNumber: 10];//转化为下面的这行
objc_msgSend(object, @selector(doSomething:withNumber), abc, 10];

对象、类、元类（object, class, metaclass）

在OC中，类也是对象。

什么意思呢？
一般在面向对象语言中，类和对象的概念是区分开来的，对象是所属类的实例。但OC中，类本身也是对象，也可以处理消息（所谓的类方法），也就是类方法和实例方法的区别。

如果我们纠结于源代码的话，可以看到OC中的对象其实本质是一个C语言结构体(struct)，其中有一个结构体成员是isa，类型是Class，指向自己的class。

NSObject的interface如下：

@interface NSObject <NSObject> {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-interface-ivars"
    Class isa  OBJC_ISA_AVAILABILITY;
#pragma clang diagnostic pop
}

+ (void)load;

+ (void)initialize;
- (instancetype)init
#if NS_ENFORCE_NSOBJECT_DESIGNATED_INITIALIZER
    NS_DESIGNATED_INITIALIZER
#endif
    ;

+ (instancetype)new OBJC_SWIFT_UNAVAILABLE("use object initializers instead");
+ (instancetype)allocWithZone:(struct _NSZone *)zone OBJC_SWIFT_UNAVAILABLE("use object initializers instead");
+ (instancetype)alloc OBJC_SWIFT_UNAVAILABLE("use object initializers instead");
- (void)dealloc OBJC_SWIFT_UNAVAILABLE("use 'deinit' to define a de-initializer");

- (void)finalize OBJC_DEPRECATED("Objective-C garbage collection is no longer supported");

- (id)copy;
- (id)mutableCopy;

+ (id)copyWithZone:(struct _NSZone *)zone OBJC_ARC_UNAVAILABLE;
+ (id)mutableCopyWithZone:(struct _NSZone *)zone OBJC_ARC_UNAVAILABLE;

+ (BOOL)instancesRespondToSelector:(SEL)aSelector;
+ (BOOL)conformsToProtocol:(Protocol *)protocol;
- (IMP)methodForSelector:(SEL)aSelector;
+ (IMP)instanceMethodForSelector:(SEL)aSelector;
- (void)doesNotRecognizeSelector:(SEL)aSelector;

- (id)forwardingTargetForSelector:(SEL)aSelector OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
- (void)forwardInvocation:(NSInvocation *)anInvocation OBJC_SWIFT_UNAVAILABLE("");
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector OBJC_SWIFT_UNAVAILABLE("");

+ (NSMethodSignature *)instanceMethodSignatureForSelector:(SEL)aSelector OBJC_SWIFT_UNAVAILABLE("");

- (BOOL)allowsWeakReference UNAVAILABLE_ATTRIBUTE;
- (BOOL)retainWeakReference UNAVAILABLE_ATTRIBUTE;

+ (BOOL)isSubclassOfClass:(Class)aClass;

+ (BOOL)resolveClassMethod:(SEL)sel OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
+ (BOOL)resolveInstanceMethod:(SEL)sel OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);

+ (NSUInteger)hash;
+ (Class)superclass;
+ (Class)class OBJC_SWIFT_UNAVAILABLE("use 'aClass.self' instead");
+ (NSString *)description;
+ (NSString *)debugDescription;

@end

其中Class的定义是：

#if !OBJC_TYPES_DEFINED
/// An opaque type that represents an Objective-C class.
typedef struct objc_class *Class;

/// Represents an instance of a class.
struct objc_object {
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;
};

/// A pointer to an instance of a class.
typedef struct objc_object *id;
#endif

我们看到：

1. Class是一个结构体struct objc_class的指针，代表一个Objective-C类
2. 结构体struct objc_object代表一个类的实例，而这个结构体内部又有Class属性，其实这个Class属性正是指向了该对象所属的类
3. id其实是struct objc_object的指针，这也解释了id为什么是任何对象的指针了

现在知道了，Class是一个结构体struct objc_class的指针，代表一个Objective-C类。那么objc_class的结构是怎样的呢？
如下：

struct objc_class {
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;

#if !__OBJC2__
    Class _Nullable super_class                              OBJC2_UNAVAILABLE;
    const char * _Nonnull name                               OBJC2_UNAVAILABLE;
    long version                                             OBJC2_UNAVAILABLE;
    long info                                                OBJC2_UNAVAILABLE;
    long instance_size                                       OBJC2_UNAVAILABLE;
    struct objc_ivar_list * _Nullable ivars                  OBJC2_UNAVAILABLE;
    struct objc_method_list * _Nullable * _Nullable methodLists                    OBJC2_UNAVAILABLE;
    struct objc_cache * _Nonnull cache                       OBJC2_UNAVAILABLE;
    struct objc_protocol_list * _Nullable protocols          OBJC2_UNAVAILABLE;
#endif

} OBJC2_UNAVAILABLE;
/* Use `Class` instead of `struct objc_class *` */

由于有typedef，Class和struct objc_class *其实是一回事，源代码中的注释也提示我们，使用Class而不要使用struct objc_class * 。

Class中保存了方法列表(methodLists)以及指向父类的指针(Class _Nullable super_class)。Class也是对象，也有isa变量，它指向哪里？？？
答案是metaclass。

此处引用一篇文章：[objc explain]: Classes and metaclasses
其中解释了类和元类等概念。这里是大地瓜的翻译。

方法、选择器、IMP（methods, selectors, IMPs）

我们已经知道了，运行时给对象发消息，对象的class保存了方法列表，那消息和方法的映射关系是怎样的？方法又是怎么执行的？

映射关系是怎样的？
class的方法列表其实是一个字典，是selectors和IMPs的键值对。IMP就是一个方法在内存中的实现。但这个映射关系是在运行时决定的，而不是编译时决定的，所以我们可以做出很多操作。
IMP一般是指向方法的指针，第一个参数是self，类型是id，第二个参数是cmd，类型为SEL，剩下的是方法的参数。

- (id)doSomethingWithInt:(int)aInt;//method
id doSomethingWithInt(id self, SEL _cmd, int aInt);//IMP

所以说运行时到底能干点什么呢？？？

创建、修改、自省class和object

class

方法如class_addIvar,class_addMethod, class_addProperty和class_addProtocol允许重建classes。
class_copyIvarList, class_copyMethodList, class_copyProtocolList和class_copyPropertyList能拿到一个class的所有内容。
而class_getClassMethod, class_getClassVariable, class_getInstanceMethod, class_getInstanceVariable, class_getMethodImplementation和class_getProperty返回单个内容。
也有一些通用的自省方法，如class_conformsToProtocol, class_respondsToSelector, class_getSuperclass。
最后，你可以使用class_createInstance来创建一个object。

ivar

这些方法能让你得到名字，内存地址和Objective-C type encoding。

method

这些方法主要用来自省，比如method_getName, method_getImplementation, method_getReturnType等等。也有一些修改的方法，包括method_setImplementation和method_exchangeImplementations。

objc

一旦拿到了object，你就可以对它做一些自省和修改。你可以get/set ivar, 使用object_copy和object_dispose来copy和free object的内存。最NB的不仅是拿到一个class，而是可以使用object_setClass来改变一个object的class。

property

属性保存了很大一部分信息。除了拿到名字，你还可以使用property_getAttributes来发现property的更多信息，如返回值、是否为atomic、getter/setter名字、是否为dynamic、背后使用的ivar名字、是否为弱引用。

protocol

Protocols有点像classes，但是精简版的，运行时的方法是一样的。你可以获取method, property, protocol列表, 检查是否实现了其他的protocol。

sel

最后我们有一些方法可以处理 selectors，比如获取名字，注册一个selector等等。

NSClassFromString/NSSelectorFromString

Class stringclass = NSClassFromString(@"NSString");
//于是我们就得到了一个string class。接下来：
NSString *myString = [stringclass stringWithString:@"Hello World"];

为什么不直接使用NSString???
有些情况下，不知道是否存在某个类。需要先判断某个类是否存在。

Class stringclass = NSClassFromString(@"NSString");
if (stringclass != nil) {
  NSString *str = [stringclass stringWithString:@"hello"];
  NSLog(@"%@", str);
}

另一个情景，就是根据不同的输入使用不同的class或method。比如解析数据，每个数据项都有不同的数据类型：

- (void)parseObject:(id)object {
    for (id data in object) {
        if ([data isKindOfClass:[NSString class]]) {
            NSLog(@"NSString = %@",data);
        } else if ([data isKindOfClass:[NSNumber class]]) {
            NSLog(@"NSNumber = %@",data);
        } else if ([data isKindOfClass:[NSDictionary class]]) {
            NSLog(@"NSDictionary = %@",data);
        }
    }
}
//runtime写法
- (void)parseObjectDynamic:(id)object { 
    for (id data in object) {
        Class dataClass = [data class];
        NSLog(@"%@ = %@", dataClass,data);
    }
}
//这里打印出来的dataClass可能并不是常见的类型，而是
2018-01-18 19:44:50.320272+0800 fuck[4975:4579429] __NSCFConstantString = 123
2018-01-18 19:44:50.320302+0800 fuck[4975:4579429] __NSCFNumber = 1
2018-01-18 19:44:50.320343+0800 fuck[4975:4579429] __NSSingleEntryDictionaryI = {
    key = value;
}
//不用担心，如果你把__NSCFConstantString和NSString进行比较的话，其实是同一个类型。

方法欺骗（Method Swizzling）

方法由两个部分组成：Selector和IMP。selector是方法的标识符（id），IMP是方法的实现，二者构成一个映射关系。这样的映射关系，一个好处就是可以进行修改。也就是selector与IMP的映射关系并不是写死的，多个selector可以指向同一个IMP。方法欺骗（method swizzling）可以进行两个方法的交换。

所以我们为什么要交换方法呢？？
首先，OC中的class有两种扩展方式，一个是继承，此时可以重写方法，也可以调用父类的实现。但是，如果你在subclass后重写了方法，你就再也无法使用子类调用原来的父类实现了。另一种方式是使用分类（category），但是即使你使用扩展，如果你扩展中重复命名了一个方法，你也只能使用重写后的方法了，原来的方法会在编译期被覆盖掉。

method swizzling就可以解决这个问题。你可以重写某个方法，而且你不用继承，还可以使用原来的实现。
这个做法就是在category中添加一个方法。通过method_exchangeImplementations这个运行时方法来交换实现。

#import "objc/runtime.h"
#import "NSString+myString.h"

@implementation NSString (myString)

+ (void)load {
    Method description = class_getInstanceMethod(self, @selector(description));
    Method myDescription = class_getInstanceMethod(self, @selector(myDescription));
    method_exchangeImplementations(description, myDescription);
}

- (NSString *)myDescription {
    return @"myDescription";
}

@end

#import <Foundation/Foundation.h>
#import "NSString+myString.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSString *str = @"1";
        NSLog(@"%@", [str description]);
        NSLog(@"%@", [str myDescription]);
    }
    return 0;
}
2018-01-20 12:08:10.409142+0800 fuck[6619:5768134] exchange in load
2018-01-20 12:08:10.409635+0800 fuck[6619:5768134] myDescription
2018-01-20 12:08:10.409678+0800 fuck[6619:5768134] 1

上述代码只是单纯的交换了方法的实现。
那么如何在不覆盖原来的方法的情况下，重写一个方法，还能调用原来的方法呢？

#import  <objc/runtime.h>

@interface NSMutableArray (LoggingAddObject)
- (void)logAddObject:(id)aObject;
@end

@implementation NSMutableArray (LoggingAddObject)

+ (void)load {
    Method addobject = class_getInstanceMethod(self, @selector(addObject:));
    Method logAddobject = class_getInstanceMethod(self, @selector(logAddObject:));
    method_exchangeImplementations(addObject, logAddObject);
}

- (void)logAddObject:(id)aobject {
    [self logAddObject:aObject];
    NSLog(@"Added object %@ to array %@", aObject, self);
}

@end

上述代码好像包含一个递归，但是，由于我们交换了实现，所以调用addObject时会跳转到logAddingObject中，然后代码中所包含的递归其实指向了addObject。所以，这样写的最终效果就是，先执行了addObject然后执行我们自定义的部分，在上述例子中，也就是打印出了一行log。
这个地方并不希望你直接调用logAddObject，而只是希望你在调用原来的addObject时有多出来的自定义实现。

另一篇国外文章，关于Method Swizzling。
这是大地瓜对于此文章的翻译。

动态继承、交换

运行时可以动态创建class，可以动态创建子类，添加新的方法。
object_setClass(myObject, [MySubclass class]);
内部是修改了isa指针，以更改其类型。

这里是KVO的更多解释。
这里是大地瓜的翻译。

动态方法处理

以上我们看到了方法交换，已有方法的处理。

那么object无法处理某个消息的时候呢？当然就崩了。大多数情况下我们的应用在这种情况就是会崩的。但是Cocoa和runtime是提供了一些处理方式的。

动态方法处理

一般情况下，处理一个方法的话，要根据selector找到对应的实现然后运行。但是有时候运行时才创建某个方法， 或者运行时这个方法才能获得全部信息。那么需要重写+resolveInstanceMethod:或者+resolveClassMethod:，最后返回YES。

+ (BOOL)resolveInstanceMethod:(SEL)aSelector {
    if (aSelector == @selector(myDynamicMethod)) {
        class_addMethod(self, aSelector, (IMP)myDynamicIMP, "v@:");
        return YES;
    }
    return [super resolveInstanceMethod:aSelector];
}

Core Data用的比较多，平时不太用得到。
若返回了NO，说明没有在运行时获得需要的方法。此时要进行消息转发。

消息转发

1. 将消息转发到另一个可以处理该消息的object
2. 多个消息都转发到同一个方法上

消息转发的步骤：
首先运行时调用-forwadrTargetForSelector:，这个方法用于将消息传递给另一个对象。
如果要修改消息，使用-forwardInvocation:，运行时将把消息包装成NSInvocation，再返回给你（也就是开发者）处理。最后调用invokeWithTarget:。

用到消息转发的主要有这么两处：
代理(NSProxy)。NSProxy是一个class，可以转发消息到另一个object。NSUndoManager是截取消息再执行，并不进行转发。
响应链：处理事件或行为到响应的对象。某个消息收到后，若当前FirstResponder不能处理该消息，则转发到下一个responder，最后找到能处理的对象进行处理，若找不到则报错。

Block作为Method IMP

一个IMP是指向方法实现的指针，前两个参数为object(self)和selector(cmd)。
implementationWithBlock()可以允许我们将block作为IMP使用。

IMP myIMP = imp_implementationWithBlock(^(id _self, NSString *string) {
  NSLog(@"Hello %@", string);
});
class_addMethod([MYClass class], @selector(sayHello:), myIMP, "V@:@");

具体实现内部，参看这篇文章。
这里是大地瓜的翻译。