目标-动作(target-action)机制是一种设计模式，用于一个对象在某个事件发生时向另一个对象发送消息。消息中要包含一个selector，用于确定要触发的方法，该方法即该机制中的动作。还要包含一个target(目标)，表示消息的接收者，例如一个控件，或者更为常见的是它的单元，以插座变量的形式保有其动作消息的目标。
   目标-动作机制符合软件开发中“高内聚，低耦合”的设计目标，降低模块间的耦合度，同时增强了模块内部的聚合度。目标一动作机制主要用于MVC设计模式中V到C的通信，通过该机制，充当V的组件只要在UI事件发生时通知C即可，之后的逻辑处理全交由C去进一步处理。
   典型的例子是UIButton的单击事件和方法的绑定，当按钮事件发生时，会触发接收者对于该事件所绑定的方法。这里的UIButton按钮即MVC中的V组件，通过目标一动作机制绑定的selector方法即属于C中的后续逻辑处理部分。
   [button addTarget:self action:@selector(click:)forControlEvents:UIControlEventTouchUpInside];

Objective-C中的类是由Class类型来表示的，而Class是一个objc_clas类型的结构体，它包含了实例变量列表(objc_ivar_list)、方法列表(objc_method_list)和协议列表(objc_protocol_list)。开发者可以通过runtime提供的函数来操作这些列表，获取成员变量列表的函数如下：
   Ivar*class_copyIvarList(Class cls,unsigned int*outCount)
   这个函数返回一个包含所有实例变量的数组，但是父类中的实例变量不会被返回。示例代码如下：
   /*新建Person类,为其添加属性*/
   #import＜Foundation/Foundation.h＞
   @interface Person:NSObject
   @properly(nonatomic,strong)NSString*name;
   @property(nonatomic,assign)NSInteger age;
   @end
   #import"Person.h"
   @interface Person ()
   @property(nonatomic,strong)NSString*sex;
   @end
   @implementation Person
   -(instancetype)init{
   if(self=[super init]){
   self.sex=@"male";
   }
   return self;
   }
   @end
   /*在控制器中获取其实例变量列表并打印*/
   Person*aperson=[[Person alloc]init];
   aperson.age=20;
   aperson.name=@"sam";

   unsigned int count=0;
   /*用一个字典装实例变量的名称和值*/
   NSMutableDictionary*dict=[NSMutableDictionary dictionary];
   Ivar*list=class_copyIvarList([aperson class].&count);
   for(int i=0;i＜count;i++){
   NSString*ivarName=INSString stringWithUTF8String:ivar_getName(1ist[i])];
   id ivarValue=[aperson valueForKey:ivarName];
   if(ivarValue){
   dict[ivarName]=ivarValue;
   }else{
   dict[ivarName]=@"";
   }
   }
   /*打印*/
   for(NSString*ivarName in dict.allKeys){
   NSLog(@"ivarName:%@,ivarValue:%@",ivarName,dict[ivarName]);
   }
   程序的打印结果如下：
   2016-11-04 19:38:19.560 01[5774:408980]ivarName:_name,ivarValue:sam
   2016-11-04 19:38:19.560 01[5774:408980]ivarName:_age,ivarValue:20
   2016-11-04 19:38:19.561 01[5774:408980]ivarName:_sex,ivarValue:male
   总结runtime函数的命名和作用，可以很容易发现以下一些规律：
   1)objc开头的函数一般都是高于类的操作，例如注册类、添加类等。
   2)class开头的函数是针对objc_class结构体的内部进行操作，例如示例中的查看实例变量列表等。
   3)object开头的函数主要是对对象进行修改，例如修改ivar的值、调用某个method等。
   4)ivar、property和method开头的函数主要是对实例变量、属性和方法的操作。

runtime之所以非常强大，很关键的一点就是它能够动态地创建一个全新的类或对象。在runtime.h文件中可以查到动态创建一个类所涉及的所有函数。
   /*创建一个新类或元类*/
   objc_allocateClassPair(Class superclass,const char*name,size_t extraBytes)
   /*注册一个通过objc_allocateClassPair方法创建的类*/
   objc_registerClassPair(Class cls)
   /*销毁一个类及其元类*/
   objc_disposeClassPair(Class cls)
   上面3个函数的作用见表。

动态创建类所涉及的3个函数

函数名

作 用

objc_allocateClassPair函数

它的作用是创建一个新类或元类。如果开发者想让这个类成为基类，那么参数superclass指 定为nil。参数extraBytes是分配给类和元类对象尾部的索引ivars的字节数，通常指定为0

objc_registerClassPair函数

当创建完新类后，需要调用这个方法来注册这个类，之后这个类才可以在程序中使用

objc_disposeClassPair函数

用于销毁一个类及其元类。需要注意的一点是，如果程序运行中还存在类或其子类的实例， 那么就不能调用该方法

   那么，如何运用上述3个函数动态地添加一个类呢?示例代码如下：
   /*创建一个新类myClass*/
   Class myClass=objc_allocateClassPair([NSObject class],"myClass",0);
   /*添加ivar*/
   //@encode(aType):返回该类型的C字符串
   class_addIvar(myClass,"_address",sizeof(NSString*),log2(sizeof(NSString*)),@encode(NSString*));
   class_addIvar(myClass,"_age",sizeof(NSUInteger),log2(sizeof(NSUInteger)),@encode(NSUInteger));
   /*注册类*/
   objc_registerClassPair(myClass);
   /*创建实例*/
   id object=[[myClass alloc]init];
   /*为ivar设置值*/
   [object setValue:@"china"forKey:@"address"];
   [object setValue:@20 forKey:@"age"];
   NSLog(@"address=%@,age=%@",[object valueForKey:@"address"],[object valueForKey:@"age"]);
   /*当类或者它的子类的实例还存在,则不能调用objc_disposeClassPair方法*/
   object=nil;
   /*销毁*/
   objc_disposeClassPair(myClass);
   程序的打印结果如下：
   2016-11-02 19:32:39.615 01[67782:2681508]address=china,age=20
   这样就通过运行时动态创建了一个继承自NSObject的myClass类，并为这个新类添加了address和age两个成员变量。特别需要注意的是，添加成员变量的方法class_addIva必须要在objc_allocateClassPair和objc_registerClassPair之间调用才行，这里涉及Objective-C中类的成员变量的偏移量，如果在类注册之后再调用class_addIva方法，那么会破坏原来类成员变量正确的偏移量，导致的后果就是会获取到错误的成员变量。

在实际开发中，如果为Category添加一个属性，那么系统将不会为这个属性设置访问器方法，也就是setter和getter方法。这时候可以使用runtime提供的关联对象方法，动态地为该属性实现访问器方法。
   开发者可以将关联对象想象成一个Objective-C对象，这个对象通过一个预先设置好的key连接到类的一个实例上。runtime提供了如下方法让一个对象连接到其他对象。
   void objc_setAssociatedObject(id object,const void*key,
   id value, objc_AssociationPolicy poliey)
   参数object是将要被关联的对象。参数key是一个void指针。参数value是关联对象，它是id类型。参数policy是指定一个内存管理策略来处理关联对象。如果指定的策略OBJC_ASSOCIATION_ASSIGN，那么被关联对象释放时，关联对象不会被释放，而如果指定的OBJC_ASSOCIATION_RETAIN或OBJC_ASSOCIATION_COPY，那么关联对象就会被释放。另外，还有OBJC_ASSOCIATION_RETAIN_NONATOMIC和OBJC_ASSOCIATIO_COPY_NONATOMIC两种策略，当需要在多个线程中处理访问关联对象的多线程代码时，就会变得非常有用。
   除此之外，runtime还提供了移除关联对象的方法：
   void objc_removeAssociatedObjects(id object)
   可以使用这个方法移除所有和参数object关联的对象，或者使用objc_setAssociatedObject函数将key指定的关联对象设置为nil。
   下面的示例代码演示了如何为Person的Category添加一个属性。
   /*为Person类的Category添加address属性*/
   #import "Person.h"
   @interface Person(Cate)
   @property(nonatomic,strong)NSString*address;
   @end
   /*在.m文件中为address属性实现访问器方法*/
   #import "Person+Cate.h"
   #import＜obje/objc-runtime.h＞
   @implementation Person(Cate)
   -(id)address {
   id value=objc_getAssociatedObject(se!f,"address");
   return value;
   }
   -(void)setAddress:(NSString*)address {
   objc_setAssociatedObject(self,"address",address,OBJC_ASSOCIATION_RETAIN);
   }
   @end
   /*在控制器中打印属性值*/
   Person*aperson=[[Person alloc]init];
   aperson.address=@"China";
   NSLog(@"address=%@",aperson.address);
   程序的打印结果如下：
   2016-11-03 19:17:40.949 01[2756:152639]aaddress=China
   结果说明已经成功地在Category中为类添加了一个新的属性，并且能够正常地使用这个属性。事实上，关联对象是使用哈希表实现的，将一个类映射到一张哈希表上，然后根据key找到关联对象，所以严格来说，关联对象和被关联对象没有任何关系，它不是存储在对象的内部。

对Objective-C对象调用方法的操作通常称为“消息传递”。在Objective-C中，如果向某对象传递消息，那么就会使用动态绑定机制来决定需要调用的方法。在底层，所有方法都是普通的C语言函数，然而对象收到消息之后，究竟该调用哪个方法则完全由runtime来决定，有时甚至可以在运行期改变方法的实现。
   在代码中给对象发送消息可以这样来编写：
   [receiver messageName:parameter];
   消息的接收者(receiver)和参数(parameter)合起来称为“消息”(message)。在编译阶段，会将上面的代码转换成C语言函数调用，所调用的函数是消息传递机制中的核心函数，叫作objc_megSend，其在objc/message.h文件下的定义如下：
   void objc_msgSend(void/*id self, SEL op,... */)
   objc_msgSend函数将消息接收者和方法名作为其基础参数。其中，参数self代表消息接收者，参数SEL代表方法名(selector，又称选择器)。每个类中的方法列表(methodLists)类似于一张表格，其中的指针都会指向方法的实现，而方法名是查表时所用的键。objc_msg Send函数正是通过这张表格来寻找应该执行的方法并跳转至其实现的。
   objc_msgSend函数会根据接收者和方法来调用适当的方法。基本流程如下：
   1)objc_msgSend函数通过isa指针在接收者所属的类中搜寻方法缓存列表(cache)和方法列表，如果能找到与方法名相符合的方法，那么就跳转至其实现代码。
   2)若是找不到，那么就会通过super_class指针沿着类的继承体系继续向上查找，如果能够找到合适的方法，那么就会跳转。
   3)如果上面两步都无法找到相符的方法，那么就会执行消息转发(message forwarding)机制。

SEL又称选择器，表示的是一个方法的selector的指针。在很多方法名中都可以看到，例如UIControl.h中事件的监听方法：
   -(void)addTarget:(nullable id)target action:(SEL)action forControlEvents:(UIControl Events)control Events;
   其中，参数action就是SEL类型。SEL的定义如下：
   typedef struct objc_selector*SEL;
   方法的selector用于表示运行时方法的名字。Objective-C在编译时，会根据每个方法的名字、参数列表，生成一个唯一的整型标识，这个标识就是SEL。正因为其具有唯一性，所以在Objective-C的同一个类中，不能存在两个同名的方法，即使参数类型不同也不行。
   开发者可以在运行时添加新的selector，也可以在运行时获取已存在的selector。可以通过下面3种方法来获取SEL。
   /*在运行时注册一个方法,返回一个SEL指针*/
   SEL sel_registerName(const char*str)
   /*编译器提供的方法*/
   @selector(selector)
   /*通过字符串获取SEL*/
   NSSelectorFromString(NSString*aSelectorName);
   事实上，工程中所有的SEL会组成一个Set集合，Set的特点就是具有唯一性，因此SEL也是唯一的。如果想要查找某个方法，那么只需要找到这个方法所对应的SEL就可以了，SEL实际上就是根据方法名Hash转换的一个字符串。

和SEL一样，IMP实际上也是个函数指针，它指向方法实现的首地址，可以把它理解为方法的具体实现。其定义如下：
   id(*IMP)(id,SEL, ...)
   前面讲到可以通过SEL指针查找方法，实际上就是查找方法的IMP。由于每个方法对应唯一的SEL，所以可以通过SEL方便快速准确地获取它所对应的IMP。取得IMP之后，就可以像调用普通的C语言函数一样来使用这个函数指针了。
   在objc/runtime.h中还定义了用以表示方法的结构体。
   typedef struct objc_method*Method;
   struct objc_method{
   SEL method_name    OBJC2_UNAVAILABLE;    //方法名
   char*method_types    OBJC2_UNAVAILABLE;
   IMP method_imp    OBJC2_UNAVAILABLE;    //方法实现
   }
   可以看到结构体objc_method包含了一个SEL和IMP，实际上它相当于在SEL和IMP之间作了一个映射。

当一个对象能处理一个消息时，就会执行正常的消息传递步骤。如果一个对象无法处理这个消息，那么就会进入消息转发。默认情况下，如果是以[object message]的方式调用方法，当object无法响应message时，那么编译器会报错。如果是以performSelector的形式来调用，那么编译器在编译时还无法确定类中到底会不会有这个方法的实现。如果没有该方法的实现，那么就会导致程序崩溃。示例代码如下：
   /*person类中并不存在eat方法*/
   Person*aperson=[[Person alloc]init];
   [aperson performSelector:@selector(eat)];
   控制台打印结果如下：
   [Person eat]:unrecognized selector sent to instance 0x600000029800
   上述这段异常信息实际上是由NSObject的doesNotRecognizeSelector:方法所抛出的，此异常信息表明Person类的实例对象无法响应eat方法。在示例中，消息转发过程以程序的崩溃而结束，但是开发者可以利用runtime，在消息转发过程中采取一些措施，而避免程序的崩溃。当然，先要理解消息转发机制的原理。消息转发机制基本分为3个阶段。
   1.动态方法解析
   对象在收到无法解读的消息后，将调用其所属类的下列类方法：
   +(BOOL)resolveInstanceMethod:(SEL)sel
   或者
   +(BOOL)resolveClassMethod:(SEL)sel
   这两个方法的参数就是那个未知的方法，返回值都是Boolean类型，表示这个类能否动态地添加一个新的方法来处理这条消息。在这里可以新增一个处理该消息的方法。
   使用这种方法的前提是：相关的方法的实现代码已经写好，只等着运行期动态插入类的MethodList中就可以了。此方案常用来实现@dynamic属性，示例代码如下：
   /*在控制器中调用Person类的实例方法eat,但是eat方法没有实现*/
   Person*aperson=[[Person alloc]init];
   [aperson performSelector:@selector(eat)];
   /*在Person类中为eat动态添加方法的实现*/
   +(BOOL)resolveInstanceMethod:(SEL)sel{
   NSString*str=NSStringFromSelector(sel);
   if([str isEqualToString:@"eat"]){
   IMP imp=method_getImplementation(class_getInstanceMethod(self,@selector(breakfast)));
   class_addMethod(self,@selector(eat),imp,"");
   }
   return[super resolveInstanceMethod:sel];
   }
   -(void)breakfast{
   NSLog(@"我吃了早餐了");
   }
   程序的打印结果如下所示：
   2016-11-05 18:25:51.897 01[11777:779796]我吃了早餐了
   在示例代码中，先将消息转化为字符串，然后检测其是否能够表示eat方法。若是eat方法，则为其设置方法的实现。程序的打印结果表明，已经成功地拦截了消息转发并对未知消息(eat)进行了处理。
   2.备用接收者
   如果在上一步中无法处理消息，那么当前接收者还有第二次机会来处理未知消息，在这一步，runtime会调用如下方法：
   -(id)forwardingTargetForSelector:(SEL)aSelector
   方法参数代表未知消息，如果当前接收者能找到备用接收者，那么将其返回；如果找不到，那么就返回nil。通过此方法可以模拟出“多重继承”的一些特性。在一个对象内部，可能还有一系列其他的对象，该对象可通过此方法将能够处理未知消息的相关内部对象返回，这样在外界看来，好像是该对象亲自处理了这些消息。示例代码如下：
   /*新建一个PersonHelper类*/
   @implementation PersonHelper
   @interface PersonHelper:NSObject
   -(void)eat;
   @end
   -(void)eat{
   NSLog(@"别人帮我吃东西");
   }
   @end
   /*在Person.m中设置PersonHelper类的实例为属性*/
   @interface Person ()
   @property(nonatomic,strong)PersonHelper*helper;
   @end
   @implementation Person
   -(instancetype)init{
   if(self=[super init]){
   _helper=[[PersonHelper alloc]init];
   }
   return self;
   }
   /*实现forwardingTargetForSelector:方法*/
   -(id)forwardingTargetForSelector:(SEL)aSelector{
   NSString*str=NSStringFromSelector(aSelector);
   if([str isEqualToString:@"eat"]){
   return_helper;
   }
   return [super forwardingTargetForSelector:aSelector];
   }
   @end
   /*在控制器中执行eat方法*/
   Person*aperson=[[Person alloc]init];
   [aperson performSelector:@selector(eat)];
   以上程序的打印结果如下：
   2016-11-05 18:45:25.870 01[11892:788458]别人帮我吃东西
   程序打印结果表明，已经成功地在第二步中将消息转发给其他对象来执行了。这里需要注意，开发者无法操作通过这一步所转发的消息。若是想在发送给备用接收者之前先修改消息内容，那就必须采用完整的消息转发机制来操作。
   3.完整的消息转发机制
   如果以上两步都无法处理未知消息，那么唯一能做的就是启用完整的消息转发机制。此时会调用如下方法：
   -(void)forwardInvocation:(NSInvocation*)anInvocation
   这里要创建NSInvocation对象，把与尚未处理的那条消息有关的全部细节都封装于其中。此对象包含选择子、目标及参数。在触发NSInvocation对象时，消息派发系统将消息指派给目标对象。当然，从这个角度看来，这一方法与第二步中的备用接收者的实现效果相等。但是事实上可以在触发消息前，先以某种方式改变消息内容，例如追加另外一个参数，或者改变消息名称等。此外，若发现某个消息不应由本类处理，则应调用父类同名方法，以便继承体系中的每个类都有机会处理此请求。
   在使用forwardInvocation：方法前，必须重写以下方法：
   -(NSMethodSignature*)methodsignatureForSelector:(SEL)aSelector
   消息转发机制使用从这个方法中获取的信息来创建NSInvocation对象。因此，开发者必须重写这个方法，为未知消息提供一个合适的方法签名。示例代码如下：
   /*在Person.m中实现完整的消息转发*/
   -(NSMethodSignature*)methodSignatureForSelector:(SEL)aSelector{
   NSMethodSignature*signature=[super methodSignatureForSelector:aSelector];
   if(!signamre&&[_helper methodSignatureForSelector:aSelector]){
   signature=[_helper methodSignatureForSelector:aSelector];
   }
   return signature;
   }
   -(void)forwardInvocation:(NSInvocation*)anInvocation{
   if([_helper respondsToSelector:anInvocation.selector]){
   [anInvocation invokeWithTarget:_helper];
   }
   }
   以上程序的打印结果如下：
   2016-11-05 19:08:13.465 01[11951:796216]别人帮我吃东西
   默认情况下，NSObject的forwardInvocation：方法实现只是简单调用了doesNot RecognizeSelector：方法，它不会转发任何消息。从某种意义上讲，forwardInvocation：方法类似一个通知中心，可以将所有未知消息都派发出去。通过runtime的消息转发机制，开发者可以为程序动态地增加很多行为，这也是丽试中常考的知识，t量。

isKindOfClass和isMemberOfClass都是Objective-C语言的内省特性方法，用于实现动态类型识别(判断某个对象是否属于某个动态类型)。但两者的类型判定深度不同。
   isKindOfClass的判“真”要求相对宽松，它是判断某个对象是否是Class类型的实例或其子类的实例。
   isMemberOfClass的判“真”要求相对更高，比isKindOfClass严格的是，isMemberOfClass只判断某个对象是否是Class类型的实例，不放宽到其子类。
   例如：Dog类继承自Animal类，对于一个Dog类型的实例对象dog，[dog isKindOfClass：[Animal class]]为真，而[dog isMemberOfClass：[Animal class]]为假。
   /*Dog类继承自父类Animal*/
   Dog*dog=[[Dog alloc]init];
   [dog isKindOfClass:[Dog class]];  //true
   [dog isKindOfClass:[Animal class]];  //true

   [dog isMemberOfClass:[Dog class]];//true
   [dog isMemberOfClass:[Animal class]];//false

Objective-C是否有私有方法和私有变量关键要看私有的定义。私有主要指通过类的封装性，将不希望让外界看到的方法或属性隐藏在类内部，只有该类可以在内部访问，外部不可见不可访问。
   表面上看，Objective-C中是可以实现私有的变量和方法的，即将它们隐藏不暴露在头文件中，不可以显式地直接访问，但是Objective-C中这种私有并不是绝对的私有，例如即使将变量和方法隐藏在.m实现文件中，开发者仍然可以利用KVC或runtime运行时机制强行访问没有暴露在头文件的变量或方法。
   Objective-C中实现变量和方法“私有”的方式主要有两种。
   1)在类的头文件中声明私有变量。
   #import＜Foundation/Foundation.h＞
   @interface Test:NSObject{
   /*头文件中定义私有变量,默认为@protected*/
   @private
   NSString*major;
   }
   @end
   2)在.m实现文件头部的类扩展区域定义私有属性或方法，其中方法可不用声明，直接在实现文件中实现即可，只要不在头文件声明的方法都对外不可见。
   #import"Test.h"
   @interface Test(){
   /*类扩展区域定义私有变量,默认就是@private*/
   int age;
   }
   /*类扩展区域定义私有属性*/
   @property(nonatomic,copy)NSString*name;
   /*类扩展区域定义私有实例方法(可省略声明,类方法的作用主要就是提供对外接口的,所以一般不会定义为私有)*/
   -(void)test;
   @end
   @implementation Test
   /*私有实例方法*/
   -(void)test{
   NSLog(@"这是个私有实例方法!");
   }
   @end
   利用KVC和runtime暴力访问私有属性和变量
   KVC访问变量不受私有权限的限制，访问代码如下：
   #import "Test.h"
   #import＜objc/runtime.h＞
   ...
   Test*test=[[Test alloc]ink];
   /*1.KVO暴力访问私有属性和私有变量*/
   [test setValue:@"albert"forKeyPath:@"name"];
   NSString*pname=[test valueForKey:@"name"];
   [test setValue:@"mathmetics"forKeyPath:@"major"];
   NSString*pmajor=[test valueForKey:@"major"];
   NSLog(@"pname:%@pmajor:%@",pname,pmajor);
   程序的运行结果为：
   2017-04-02 11:58:56.255723 CommandLine[99973:3239125]pname:albert pmajor:mathmetics
   运行时可以使用class_copyIvarList函数获取类对象的Ivar变量列表，然后可使用object_getIvar和object_setIvar运行时函数对变量进行暴力访问。
   #import "Test.h"
   #import＜objc/runtime.h＞
   ...
   Test*test=[[Test alloc]init];
   /*2.运行时暴力访问私有属性和私有变量(ARC)*/
   /*获取实例变量列表*/
   unsigned int count=0;
   Ivar*members=class_copyIvarList([Test class],&count);
   /*打印所有的变量名及其类型*/
   for(inti=0;i＜count;i++){
   const char*memberName=ivar_getName(members[i]);
   const char*memberType=ivar_getTypeEncoding(members[i]);
   NSLog(@"name:%s type:%s",memberName,memberType);
   }
   /*访问私有属性和变量*/
   Ivar varname=members[0];
   Ivar varmajor=members[1];
   object_setIvar(test,varname,@"albert");
   object_setIvar(test,varmajor,@"mathmetics");
   NSString*name=object_getIvar(test,varname);
   NSString*major=object_getIvar(test,varmajor);
   NSLog(@"pname:%@",name);
   NSLog(@"pmajor:%@",major);
   /*要手动释放*/
   free(members);
   程序的运行结果为：
   2017-04-0212:07:22.105758 CommandLine[189:3242353]name:majortype:@"NSString"
   2017-04-02 12:07:22.105930 CommandLine[189:3242353]name:_name type:@"NSString"
   2017-04-02 12:07:22.106156 CommandLine[189:3242353]pname:albert
   2017-04-02 12:07:22.106221 CommandLine[189:3242353]pmajor:mathmetics
   Runtime暴力访问对象私有方法
   和访问私有变量类似，这里使用class_copyMethodList运行时函数获取类对象中的方法列表，然后使用performSelector函数执行某个方法。这里只展示了实例方法的访问，类方法的访问也类似，另外还可以使用class_addMethod运行时函数往类对象中强行添加新的方法，具体见Method Swizzling部分。
   #import"Test.h"
   #import＜objc/runtime.h＞
   ...
   Test*test=[[Test alloc]init];
   /*运行时暴力访问私有方法*/
   /*获取类对象方法列表*/
   unsigned int count=0:
   Method*methods=class_copyMethodList([Test class],&count);
   /*获取第一个方法的方法名*/
   SEL sel=method_getName(methods[0]);
   /*执行该方法*/
   [test performSelector:sel];

在runtime库中，对象是用C语言中的结构体表示，而方法用C语言中的函数来实现，另外也加入了一些额外的特性。这些结构体和函数被Runtime函数封装后，开发者就可以利用运行时特性在程序运行阶段动态地创建、查看、修改类、对象和它们的方法。在iOS的SDK中，文件夹usr/include/objc下的文件基本都是和运行时相关的文件，其中使用的函数主要定义在message.h和runtime.h两个文件中。在这两个文件中，包含了运行时对象结构体的描述和对运行时进行操作的函数。
   1.类(Class)
   在runtime中，Objective-C中的类是由Class类型来表示的，通过objc/objc.h可以查看到Class类型实际上是指向objc_class结构的指针。它的定义如下：
   ///An opaque type that represents all Objective-C class.
   typedef struct objc_class *Class;
   通过查看objc/runtime.h文件，可以看到objc_class结构体的定义如下：
   struct objc_class{
   Class isa  OBJC_ISA_AVAILABILITY;

   #if!__OBJC2__
   Class super_classOBJC2_UNAVAILABLE;
   const char*name  OBJC2_UNAVAILABLE;
   long version    OBJC2_UNAVAILABLE;
   long info  OBJC2_UNAVAILABLE;
   long instance_size  OBJC2_UNAVAILABLE;
   struct objc_iVar_list*ivarsOBJC2_UNAVAILABLE;
   struct objc_method_list**methodListsOBJC2_UNAVAILABLE;
   struct objc_cache*cache  OBJC2_UNAVAILABLE;
   struct objc_protocol_list*protocols  OBJC2_UNAVAILABLE;
   #endif
   }OBJC2_UNAVAILABLE;
   /*Use 'Class' instead of 'struct objc_elass*'*/
   在这个结构体中，有几个重要的字段，它们的含义如下。
   1)isa：在Objective-C中，所有的类自身也是一个对象，这个对象的Class里面也存在一个isa指针。对象需要通过isa指针找到它的类，类需要通过isa找到它的元类(Meta Class)。元类可以理解为类对象的类，每个类都会有一个单独的元类。事实上，元类也是一个类，它也存在isa指针，它的isa指针指向父类的元类。也就是说，任何NSObject继承体系下的元类都使用NSObject的元类作为自己的所属类，而基类的元类的isa指针是指向它自己。这样就形成了一个完美的闭环。isa指针在调用实例方法和类方法的时候会起到重要的作用。
   2)super_class：指向该类的父类，如果该类已经是最顶层的类(Root Class)，那么super_class就是nil。
   3)cache：它主要用于缓存类中最近使用的方法。当开发者调用过一个方法后，runtime会将这个方法缓存到cache列表中，如果再次调用这个方法，那么runtime就会优先去cache中查找，如果cache没有，那么就会去methodLists中查找该方法。这样就大大提高了调用方法的效率。
   4)ivars：指向该类的成员变量链表。
   5)methodLists：指向方法定义的链表。
   6)protocols：指向协议链表。
   这些类型的定义将一个类进行了完全的分解，将类的定义或者对象的每一个部分都抽象为一个类型Type，这样对操作一个类属性和方法非常方便。开发者可以通过runtime提供的函数获取类结构体中的各个类型的值。例如，如果想要获取Class的name，那么可以通过如下的方法获取。
   /*导入runtime头文件*/
   #import＜objc/runtime.h＞
   #import＜objc/message.h＞
   /*获取ClassName*/
   Class personClass=Person.class;
   const char*className=class_getName(personClass);
   NSLog(@"%s",className);
   2.对象(objc_object)
   在objc/objc.h中，同样可以找到关于类的实例定义。
   ///Represents an instance of a class.
   struct objc_object{
   Class isa  OBJC_ISA_AVAILABILITY;
   };
   从以上代码可以看到，在objc_object结构体中只有一个字段，即指向其类的isa指针。通过这个指针，runtime会找到这个实例对象所属的类。当创建一个特定类的实例对象时，分配的内存包含一个objc_object数据结构，然后是类的实例变量的数据。NSObject类的alloc和allocWithZone：方法使用方法class_createInstance来创建objc_object数据结构。
   在objc.h中还可以看到id类型的定义。
   ///A pointer to an instance of a class.
   typedef struct objc_object*id:
   显然，它也是一个objc_object结构类型的指针。它的存在可以让开发者实现类似于C++中泛型的一些操作。该类型的对象可以转换为任何一个种对象，有点类似C语言中void*指针类型的作用。