• 字符串反转
• 链表反转
• 有序数组合并
• Hash算法
• 查找两个子视图的共同父视图
• 求无序数组当中的中位数

一、字符串反转
给定字符串 "hello,world",实现将其反转。输出结果：dlrow,olleh

- (void)charReverse

{

    NSString * string = @"hello,world";

    

    NSLog(@"%@",string);

    

    NSMutableString * reverString = [NSMutableString stringWithString:string];

    

    for (NSInteger i = 0; i < (string.length + 1)/2; i++) {

        

        [reverString replaceCharactersInRange:NSMakeRange(i, 1) withString:[string substringWithRange:NSMakeRange(string.length - i - 1, 1)]];

        

        [reverString replaceCharactersInRange:NSMakeRange(string.length - i - 1, 1) withString:[string substringWithRange:NSMakeRange(i, 1)]];

    }

    

    NSLog(@"reverString:%@",reverString);

    

    //C

    char ch[100];

    

    memcpy(ch, [string cStringUsingEncoding:NSUTF8StringEncoding], [string length]);



   //设置两个指针，一个指向字符串开头，一个指向字符串末尾

    char * begin = ch;

    

    char * end = ch + strlen(ch) - 1;

   

//遍历字符数组，逐步交换两个指针所指向的内容，同时移动指针到对应的下个位置，直至begin>=end 

    while (begin < end) {

        

        char temp = *begin;

        

        *(begin++) = *end;

        

        *(end--) = temp;

    }

    

    NSLog(@"reverseChar[]:%s",ch);

}

复制代码

二、链表反转
反转前：1->2->3->4->NULL
反转后：4->3->2->1->NULL

/**  定义一个链表  */

struct Node {

    

    NSInteger data;

    

    struct Node * next;

};



- (void)listReverse

{

    struct Node * p = [self constructList];

    

    [self printList:p];

    

    //反转后的链表头部

    struct Node * newH = NULL;

    //头插法

    while (p != NULL) {

        

        //记录下一个结点

        struct Node * temp = p->next;

        //当前结点的next指向新链表的头部

        p->next = newH;

        //更改新链表头部为当前结点

        newH = p;

        //移动p到下一个结点

        p = temp;

    }

    

    [self printList:newH];

}

/**

 打印链表



 @param head 给定链表

 */

- (void)printList:(struct Node *)head

{

    struct Node * temp = head;

    

    printf("list is : ");

    

    while (temp != NULL) {

        

        printf("%zd ",temp->data);

        

        temp = temp->next;

    }

    

    printf("\n");

}





/**  构造链表  */

- (struct Node *)constructList

{

    //头结点

    struct Node *head = NULL;

    //尾结点

    struct Node *cur = NULL;

    

    for (NSInteger i = 0; i < 10; i++) {

        

        struct Node *node = malloc(sizeof(struct Node));

        

        node->data = i;

        

        //头结点为空，新结点即为头结点

        if (head == NULL) {

            

            head = node;

            

        }else{

            //当前结点的next为尾结点

            cur->next = node;

        }

        

        //设置当前结点为新结点

        cur = node;

    }

    

    return head;

}



复制代码

三、有序数组合并
将有序数组 {1,4,6,7,9} 和 {2,3,5,6,8,9,10,11,12} 合并为
{1,2,3,4,5,6,6,7,8,9,9,10,11,12}

- (void)orderListMerge

{

    int aLen = 5,bLen = 9;

    

    int a[] = {1,4,6,7,9};

    

    int b[] = {2,3,5,6,8,9,10,11,12};

    

    [self printList:a length:aLen];

    

    [self printList:b length:bLen];

    

    int result[14];

    

    int p = 0,q = 0,i = 0;//p和q分别为a和b的下标，i为合并结果数组的下标

    

    //任一数组没有达到s边界则进行遍历

    while (p < aLen && q < bLen) {

        

        //如果a数组对应位置的值小于b数组对应位置的值,则存储a数组的值，并移动a数组的下标与合并结果数组的下标

        if (a[p] < b[q]) result[i++] = a[p++];

        

        //否则存储b数组的值，并移动b数组的下标与合并结果数组的下标

        else result[i++] = b[q++];

    }

    

    //如果a数组有剩余，将a数组剩余部分拼接到合并结果数组的后面

    while (++p < aLen) {

        

        result[i++] = a[p];

    }

    

    //如果b数组有剩余，将b数组剩余部分拼接到合并结果数组的后面

    while (q < bLen) {

        

        result[i++] = b[q++];

    }

    

    [self printList:result length:aLen + bLen];

}

- (void)printList:(int [])list length:(int)length

{

    for (int i = 0; i < length; i++) {

        

        printf("%d ",list[i]);

    }

    

    printf("\n");

}

复制代码

四、HASH算法

• 哈希表
  例：给定值是字母a，对应ASCII码值是97，数组索引下标为97。
  这里的ASCII码，就算是一种哈希函数，存储和查找都通过该函数，有效地提高查找效率。
• 在一个字符串中找到第一个只出现一次的字符。如输入"abaccdeff"，输出'b'
  
  字符(char)是一个长度为8的数据类型，因此总共有256种可能。每个字母根据其ASCII码值作为数组下标对应数组种的一个数字。数组中存储的是每个字符出现的次数。

- (void)hashTest

{

    NSString * testString = @"hhaabccdeef";

    

    char testCh[100];

    

    memcpy(testCh, [testString cStringUsingEncoding:NSUTF8StringEncoding], [testString length]);

    

    int list[256];

    

    for (int i = 0; i < 256; i++) {

        

        list[i] = 0;

    }

    

    char *p = testCh;

    

    char result = '\0';

    

    while (*p != result) {

        

        list[*(p++)]++;

    }

    

    p = testCh;

    

    while (*p != result) {

        

        if (list[*p] == 1) {



            result = *p;

            

            break;

        }

        

        p++;

    }

    

    printf("result:%c",result);

}

复制代码

五、查找两个子视图的共同父视图
思路:分别记录两个子视图的所有父视图并保存到数组中，然后倒序寻找,直至找到第一个不一样的父视图。

- (void)findCommonSuperViews:(UIView *)view1 view2:(UIView *)view2

{

    NSArray * superViews1 = [self findSuperViews:view1];

    

    NSArray * superViews2 = [self findSuperViews:view2];

    

    NSMutableArray * resultArray = [NSMutableArray array];

    

    int i = 0;

    

    while (i < MIN(superViews1.count, superViews2.count)) {

        

        UIView *super1 = superViews1[superViews1.count - i - 1];

        

        UIView *super2 = superViews2[superViews2.count - i - 1];

        

        if (super1 == super2) {

            

            [resultArray addObject:super1];

            

            i++;

            

        }else{

            

            break;

        }

    }

    

    NSLog(@"resultArray:%@",resultArray);

    

}

- (NSArray *)findSuperViews:(UIView *)view

{

    UIView * temp = view.superview;

    

    NSMutableArray * result = [NSMutableArray array];

    

    while (temp) {

        

        [result addObject:temp];

        

        temp = temp.superview;

    }

    

    return result;

}

复制代码

六、求无序数组中的中位数
中位数：当数组个数n为奇数时，为(n + 1)/2，即是最中间那个数字；当n为偶数时，为(n/2 + (n/2 + 1))/2,即是中间两个数字的平均数。
首先要先去了解一些几种排序算法:iOS排序算法
思路:

• 1.排序算法+中位数
  首先用冒泡排序、快速排序、堆排序、希尔排序等排序算法将所给数组排序，然后取出其中位数即可。
• 2.利用快排思想

1. 构建WKWebView

self.webView = [[WKWebView alloc] init];
// 创建请求
NSURLRequest *request =[NSURLRequest requestWithURL:[NSURL URLWithString:@"https://www.jianshu.com"]];
// 加载网页
[self.webView loadRequest:request];

self.webView.scrollView.scrollEnabled = NO;
self.webView.scrollView.bounces = NO;
self.webView.scrollView.showsVerticalScrollIndicator = NO;
self.webView.autoresizingMask = UIViewAutoresizingFlexibleHeight;

// 将webView添加到界面
[self.contentView addSubview:self.webView];

2. cell高度适应WKWebView的内容

cell.webView.navigationDelegate = self;

#pragma mark - WKNavigationDelegate
- (void)webView:(WKWebView *)webView didFinishNavigation:(WKNavigation *)navigation {
    
    [webView evaluateJavaScript:@"document.body.offsetHeight" completionHandler:^(id _Nullable result, NSError * _Nullable error) {
        // 计算webView高度
        self.webViewCellHeight = [result doubleValue];
        // 刷新tableView
        [self.tableView reloadData];
    }];
}

3. 解决加载空白问题
原因：由于WKWebView采用的lazy加载模式，所在的scrollView的滚动被禁用，导致被嵌套的WKCompositingView不进行数据加载。
详细细节请参考：WKWebView刷新机制小探

#pragma mark - UIScrollViewDelegate
- (void)scrollViewDidScroll:(UIScrollView *)scrollView {
    // 判断webView所在的cell是否可见，如果可见就layout
    NSArray *cells = self.tableView.visibleCells;
    for (UITableViewCell *cell in cells) {
        if ([cell isKindOfClass:[TraitWebViewCell class]]) {
            TraitWebViewCell *webCell = (TraitWebViewCell *)cell;
            
            [webCell.webView setNeedsLayout];
        }
    }
    
}

• 我们先来看看这个创建好的objc占多少个字节

int main(int argc, char * argv[]) {

    

    @autoreleasepool {

        // Setup code that might create autoreleased objects goes here.

        //定义一个objc

        NSObject *objc = [[NSObject alloc]init];

        //打印内存

        NSLog(@"tu-%zd",class_getInstanceSize([NSObject class]));

        NSLog(@"tu-%zd",malloc_size((__bridge const void *)(objc)));

    }

    

}

其打印结果为:

objc打印结果

• 
  为什么一个是8一个是16

二.内存对齐

• 在上面的基础上我们新建一个类Student继承NSObject，那么对于student的底层C++编译实现就变成了：

struct Student {

    struct NSObject_IMPL NSOBJECT_IVARS;

};

也就是说，继承关系，子类直接将父类的isa引用进来

• 对于class_getInstanceSize（也就是类本质的内存对其）
  
  1.在student中创建成员变量：

@interface Student : NSObject

{

    @public

    int _age;

    int _no;

    int _tc;

}

@end

其底层C++编译结构体就变成了

struct Student {

    struct NSObject_IMPL NSOBJECT_IVARS;

    int _age;

    int _no;

    int _tc;

};

• 打印结果：

 //定义一个objc

        Student *objc = [[Student alloc]init];

        //打印内存

        NSLog(@"tu-%zd",class_getInstanceSize([Student class]));

        NSLog(@"tu-%zd",malloc_size((__bridge const void *)(objc)));

2020-09-08 12:35:27.158568+0800 OC底层[1549:79836] tu-24

2020-09-08 12:35:27.159046+0800 OC底层[1549:79836] tu-32

• 先来说说24的由来

由于创建对象的时候，内存是以8对齐，上面我们讲到一个对象里面包含了一个isa占8个字节，对于student来说它有四个成员变量，isa，age，no，tc，共占8+4+4+4=20字节，但是由于内存以8对齐的原因，我们看到的输出是24，

所以class_getInstanceSize在计算实例大小的时候就是24，其白色区域表示空出了四个字节

再来看看32的由来
上面我们说到malloc_size指的是实际堆分配的空间，它以16字节对齐

三.添加属性

@interface Student : NSObject

{

    @public

    int _age;

    int _no;

    int _tc;



}

@property (nonatomic, strong) NSString *name;

@property (nonatomic, strong) NSArray *array;

@end

struct Student {

    struct NSObject_IMPL NSOBJECT_IVARS;

    int _age;

    int _no;

    int _tc;

    NSString _name;

    NSArray _array;

};

我们在开发中，常常遇到这样的问题，点击某一个TabBar后，本TabBar上的控制器页面数据不刷新，原因是因为在App启动之后，第一次点击本TabBar后页面已经走了viewDidLoad，所以除了重新启动不会再次走viewDidLoad，如果把请求方法写在viewDidLoad中，当然不会再次触发啦，但是，苹果早考虑到这个问题，不用咱们写通知事件什么的，废话有点多了，看代码详解：

首先需要在本控制器签订TabBar的协议

UITabBarControllerDelegate

一定要看清楚协议，如果警报 Assigning to 'id<UITabBarControllerDelegate> _Nullable' from incompatible type 'RCFollowOrderViewController *const __strong'那么就证明你的协议签成了UITabBarDelegate

在viewDidLoad 请求一次 

[self requestdata];

协议方法：

//点击的时候触发的方法

-(void)tabBarController:(UITabBarController *)tabBarController didSelectViewController:(UIViewController *)viewController{

    if (self.tabBarController.selectedIndex==1) {

        [self requestdata];

    }

}

//防止同一个页面一直点击tabbar 的方法

-(BOOL)tabBarController:(UITabBarController *)tabBarController shouldSelectViewController:(UIViewController *)viewController{

    UIViewController *tbselect=tabBarController.selectedViewController;

    if([tbselect isEqual:viewController]){

        returnNO;

    }

    returnYES;

}

如果想要点击TabBar一次，就刷新一次界面，就不写防止重复点击的代理方法，试下效果，搞定！

//将标签数组根据type以及其他参数进行分组装入数组
- (void)disposeTags:(NSArray *)aryName aryCount:(NSArray *)aryCount{
    NSMutableArray *tags = [NSMutableArray new];//纵向数组
    NSMutableArray *subTags = [NSMutableArray new];//横向数组
    
    float originX = _tagOriginX;
    for (NSString *tagTitle in aryName) {
        NSUInteger index = [aryName indexOfObject:tagTitle];
        
        //计算每个tag的宽度
        CGSize contentSize = [tagTitle fdd_sizeWithFont:[UIFont systemFontOfSize:14] constrainedToSize:CGSizeMake(self.frame.size.width-_tagOriginX*2, MAXFLOAT)];
        
        NSMutableDictionary *dict = [NSMutableDictionary new];
        dict[@"tagTitle"] = tagTitle;//标签标题
        dict[@"tagCount"] =aryCount[index];
        dict[@"viewWith"] = [NSString stringWithFormat:@"%f",contentSize.width+_tagSpace+30];//标签的宽度
        
        if (index == 0) {
            dict[@"originX"] = [NSString stringWithFormat:@"%f",originX];//标签的X坐标
            [subTags addObject:dict];
        } else {
                if (originX + contentSize.width > self.frame.size.width-_tagOriginX*2) {
                    //当前标签的X坐标+当前标签的长度>屏幕的横向总长度则换行
                    [tags addObject:subTags];
                    //换行标签的起点坐标初始化
                    originX = _tagOriginX;
                    dict[@"originX"] = [NSString stringWithFormat:@"%f",originX];//标签的X坐标
                    subTags = [NSMutableArray new];
                    [subTags addObject:dict];
                } else {
                    //如果没有超过屏幕则继续加在前一个数组里
                    dict[@"originX"] = [NSString stringWithFormat:@"%f",originX];//标签的X坐标
                    [subTags addObject:dict];
                }
            }
        
        if (index +1 == aryName.count) {
            //最后一个标签加完将横向数组加到纵向数组中
            [tags addObject:subTags];
            disposeAry = tags;
        }
        
        //标签的X坐标每次都是前一个标签的宽度+标签左右空隙+标签距下个标签的距离
        originX += contentSize.width+_tagHorizontalSpace+_tagSpace+30;
    }
}

#pragma mark - 扩展方法


@implementation NSString (FDDExtention)



- (CGSize)fdd_sizeWithFont:(UIFont *)font constrainedToSize:(CGSize)size {

    CGSize resultSize;

    if ([self respondsToSelector:@selector(boundingRectWithSize:options:attributes:context:)]) {

        NSMethodSignature *signature = [[self class] instanceMethodSignatureForSelector:@selector(boundingRectWithSize:options:attributes:context:)];

        NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];

        [invocation setTarget:self];

        [invocation setSelector:@selector(boundingRectWithSize:options:attributes:context:)];

        NSDictionary *attributes = @{ NSFontAttributeName:font };

        NSStringDrawingOptions options = NSStringDrawingUsesLineFragmentOrigin;

        NSStringDrawingContext *context;

        [invocation setArgument:&size atIndex:2];

        [invocation setArgument:&options atIndex:3];

        [invocation setArgument:&attributes atIndex:4];

        [invocation setArgument:&context atIndex:5];

        [invocation invoke];

        CGRect rect;

        [invocation getReturnValue:&rect];

        resultSize = rect.size;

    } else {

        NSMethodSignature *signature = [[self class] instanceMethodSignatureForSelector:@selector(sizeWithFont:constrainedToSize:)];

        NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];

        [invocation setTarget:self];

        [invocation setSelector:@selector(sizeWithFont:constrainedToSize:)];

        [invocation setArgument:&font atIndex:2];

        [invocation setArgument:&size atIndex:3];

        [invocation invoke];

        [invocation getReturnValue:&resultSize];

    }

    return resultSize;

} 

字符串长度计算完成了，下面就可以进行所有字符串排列的高度了。其实这个蛮简单的 ，统计数组有多少个元素就代表标签排布有多少行。

-(void)setTagAryName:(NSArray *)tagAryName aryCount:(NSArray *)aryCount delegate:(id)delegate{
    _tagDelegate=delegate;
    [self disposeTags:tagAryName aryCount:aryCount];
    UILabel *label=[[UILabel alloc]initWithFrame:CGRectMake(_tagOriginX, 0, 200, 30)];
    label.text=@"事件类别统计：";
    label.textColor=_titleColor;
    label.textAlignment=NSTextAlignmentLeft;
    label.adjustsFontSizeToFitWidth=YES;
    [self addSubview:label];
    //遍历标签数组,将标签显示在界面上,并给每个标签打上tag加以区分
    for (NSArray *iTags in disposeAry) {
        NSUInteger i = [disposeAry indexOfObject:iTags];
        
        for (NSDictionary *tagDic in iTags) {
            NSUInteger j = [iTags indexOfObject:tagDic];
            
            NSString *tagTitle = tagDic[@"tagTitle"];
            float originX = [tagDic[@"originX"] floatValue];
            float viewWith = [tagDic[@"viewWith"] floatValue];
            NSString *count = tagDic[@"tagCount"];
            UIView *NCView=[[UIView alloc]initWithFrame:CGRectMake(originX, _tagOriginY+i*(_tagHeight+_tagVerticalSpace), viewWith, _tagHeight)];
            [self addSubview:NCView];
            UIButton *button = [UIButton buttonWithType:UIButtonTypeCustom];
            button.frame=CGRectMake(0, 0, viewWith-30, _tagHeight);
            button.layer.borderColor = _borderColor.CGColor;
            button.layer.borderWidth = _borderWidth;
            button.layer.masksToBounds = _masksToBounds;
            button.layer.cornerRadius = _cornerRadius;
            button.titleLabel.font = [UIFont systemFontOfSize:_titleSize];
            [button setTitle:tagTitle forState:UIControlStateNormal];
            [button setTitleColor:_titleColor forState:UIControlStateNormal];
            [button setBackgroundImage:_normalBackgroundImage forState:UIControlStateNormal];
            [button setBackgroundImage:_highlightedBackgroundImage forState:UIControlStateHighlighted];
            button.tag = i*iTags.count+j;
            [button addTarget:self action:@selector(buttonAction:) forControlEvents:UIControlEventTouchUpInside];
            UILabel *label=[[UILabel alloc]initWithFrame:CGRectMake(viewWith-30, 0, 30, _tagHeight)];
            label.text=[NSString stringWithFormat:@"X%@",count];
            label.textAlignment=NSTextAlignmentCenter;
            label.adjustsFontSizeToFitWidth=YES;
            label.textColor=_titleColor;
            [NCView addSubview:button];
            [NCView addSubview:label];
        }
    }
    self.countLabel=[[UILabel alloc]initWithFrame:CGRectMake(_tagOriginX, [self getDisposeTagsViewHeight:disposeAry], 100, 30)];
    self.countLabel.text=[NSString stringWithFormat:@"总计：%ld次",_times];
    self.countLabel.textAlignment=NSTextAlignmentLeft;
    self.countLabel.adjustsFontSizeToFitWidth=YES;
    self.countLabel.textColor=_titleColor;
    [self addSubview:self.countLabel];
    if (disposeAry.count > 0) {
            float contentSizeHeight = _tagOriginY+disposeAry.count*(_tagHeight+_tagVerticalSpace);
            self.contentSize = CGSizeMake(self.frame.size.width,contentSizeHeight);
    }
    
    if (self.frame.size.height <= 0) {
        self.frame = CGRectMake(CGRectGetMinX([self frame]), CGRectGetMinY([self frame]), CGRectGetWidth([self frame]), [self getDisposeTagsViewHeight:disposeAry]+30);
    }


}

//计算出全部展示的高度,让maxHeight等于计算出的高度即可,初始化不需要设置高度
NSArray *tagAryCount=@[@"10",@"8",@"7",@"9",@"2",@"4",@"5",@"3",@"4"];
    NSArray* tagAryName = @[@"黑色玫瑰",@"比尔沃吉特",@"钢铁烈阳",@"德玛西亚",@"祖安",@"巨神峰",@"雷瑟守备祖安",@"诺克萨斯暗影岛",@"弗雷尔卓德"];
    ZHLbView * tagsView = [[ZHLbView alloc] initWithFrame:CGRectMake(0, 200, self.view.frame.size.width, 0)];
    [tagsView setTagAryName:tagAryName aryCount:tagAryCount delegate:self];
    [self.view addSubview:tagsView];

OC对象的分类

OC对象主要分为三类：instance(实例对象)，class (类对象)，meta-class（元类对象）

• 
  

  实例对象：

  
  实例对象就是通过类调用alloc来产生的instance，每一次调用的alloc都是产生新的实例对象，内存地址都是不一样的，占据着不同的内存 eg：

        NSObject *objc1 = [[NSObject alloc]init];

        NSObject *objc2 = [[NSObject alloc]init];

        

        NSLog(@"instance----%p %p",objc1,objc2);

        Class Classobjc1 = [objc1 class];

        Class Classobjc2 = [objc2 class];

        Class Classobjc3 = object_getClass(objc1);

        Class Classobjc4 = object_getClass(objc2);

        Class Classobjc5 = [NSObject class];

        NSLog(@"class---%p %p %p %p %p ",Classobjc1,Classobjc2,Classobjc3,Classobjc4,Classobjc5);

• 2.initialize的打印

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        

        [TCPerson alloc];

    }

    return 0;

}

2020-12-04 14:59:17.417072+0800 TCCateogry[1616:79391] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        

        [TCPerson alloc];

        [TCPerson alloc];

        [TCPerson alloc];

        [TCPerson alloc];

    }

    return 0;

}

2020-12-04 15:11:12.246442+0800 TCCateogry[1659:85317] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCStudent alloc];

      

    }

    return 0;

}

2020-12-04 15:14:58.705423+0800 TCCateogry[1705:87507] TCPerson (TCtest2) +initialize

2020-12-04 15:14:58.705750+0800 TCCateogry[1705:87507] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson alloc];

        [TCPerson alloc];

        [TCStudent alloc];

        [TCStudent alloc];

    }

    return 0;

}

020-12-04 15:23:27.168243+0800 TCCateogry[1731:91248] TCPerson (TCtest2) +initialize

2020-12-04 15:23:27.168601+0800 TCCateogry[1731:91248] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

#import "TCStudent.h"



@implementation TCStudent

//+ (void)initialize{

//    NSLog(@"TCStudent +initialize");

//}

@end

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson alloc];   

        [TCStudent alloc];

    }

    return 0;

}

输出结果：

2020-12-04 15:37:09.055459+0800 TCCateogry[1822:98237] TCPerson (TCtest2) +initialize

2020-12-04 15:37:09.055775+0800 TCCateogry[1822:98237] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

如果子类（子类的分类实现initialize）不实现initialize，则子类的initialize不会调用，调用子类分类的initialize（当然多个分类的话，调用哪个的initialize取决于编译顺序）

类别里面有负载方法么？

• 答：分类里面肯定有负载

#import "TCPerson.h"



@implementation TCPerson

  (void)load{

    

}

@end

#import "TCPerson TCtest1.h"



@implementation TCPerson (TCtest1)

  (void)load{

    

}

@end

#import "TCPerson TCTest2.h"



@implementation TCPerson (TCTest2)

  (void)load{

    

}

@end

load方法什么时候调用？

• 
  

  load方法在运行时加载类和分类的时候调用load

• #import 
  
  
  
  int main(int argc, const char * argv[]) {
  
      @autoreleasepool {
  
          
  
      }
  
      return 0;
  
  }
  
  
  
  

  
  

  @implementation TCPerson
  
  + (void)load{
  
      NSLog(@"TCPerson +load");
  
  }
  
  @end
  
  
  
  
  
  @implementation TCPerson (TCtest1)
  
  + (void)load{
  
      NSLog(@"TCPerson (TCtest1) +load");
  
  }
  
  @end
  
  @implementation TCPerson (TCTest2)
  
  + (void)load{
  
      NSLog(@"TCPerson (TCtest2) +load");
  
  }
  
  @end
  
  

  
  

  可以看到我们在main里面不导入任何的头文件，也不引用任何的类，直接运行，控制台输出结果：

  
  

  从输出结果我们可以抛光，三个负载方法都被调用

  
  
  

  如果不是，到底分类的方法是怎么调用的？

  
  

  
  
  • 
    

    首先我们在TCPerson申明一个方法+（void）test和在它的两个分类都重写+（void）test

  #import 
  
  
  
  NS_ASSUME_NONNULL_BEGIN
  
  
  
  @interface TCPerson : NSObject
  
  + (void)test;
  
  @end
  
  
  
  NS_ASSUME_NONNULL_END
  
  
  
  

  
  

  #import "TCPerson.h"
  
  
  
  @implementation TCPerson
  
  + (void)load{
  
      NSLog(@"TCPerson +load");
  
  }
  
  + (void)test{
  
      NSLog(@"TCPerson +test");
  
  }
  
  @end
  
  

  
  

  分类重写测试

  #import "TCPerson+TCtest1.h"
  
  
  
  @implementation TCPerson (TCtest1)
  
  + (void)load{
  
      NSLog(@"TCPerson (TCtest1) +load");
  
  }
  
  + (void)test{
  
      NSLog(@"TCPerson (TCtest1) +test1");
  
  }
  
  @end
  
  

  
  

  #import "TCPerson+TCTest2.h"
  
  
  
  @implementation TCPerson (TCTest2)
  
  + (void)load{
  
      NSLog(@"TCPerson (TCtest2) +load");
  
  }
  
  + (void)test{
  
      NSLog(@"TCPerson (TCtest2) +test2");
  
  }
  
  @end
  
  

  
  

  在主要里面我们调用测试

  #import 
  
  #import "TCPerson.h"
  
  int main(int argc, const char * argv[]) {
  
      @autoreleasepool {
  
          [TCPerson test];
  
      }
  
      return 0;
  
  }
  
  

  
  

  输出结果：

  从输出结果中我们可以看到，只有分类2中的测试被调用，为什么只调用分类2中的测试了？
  

  因为编译顺序是分类2在后，1在前，这个时候我们改变编译顺序（进行文件就行了）
  
  其输出结果为：

  细心的老铁会看到，为什么load方法一直都在调用，这是为什么了？它和test方法到底有什么不同了？真的是我们理解中的load不覆盖，test coverage了，所以才出现这种情况么？

  
  

  我们打印TCPerson的类方法

  void printMethodNamesOfClass(Class cls)
  
  {
  
      unsigned int count;
  
      // 获得方法数组
  
      Method *methodList = class_copyMethodList(cls, &count);
  
      
  
      // 存储方法名
  
      NSMutableString *methodNames = [NSMutableString string];
  
      
  
      // 遍历所有的方法
  
      for (int i = 0; i < count; i++) {
  
          // 获得方法
  
          Method method = methodList[I];
  
          // 获得方法名
  
          NSString *methodName = NSStringFromSelector(method_getName(method));
  
          // 拼接方法名
  
          [methodNames appendString:methodName];
  
          [methodNames appendString:@", "];
  
      }
  
      
  
      // 释放
  
      free(methodList);
  
      
  
      // 打印方法名
  
      NSLog(@"%@ %@", cls, methodNames);
  
  }
  
  int main(int argc, const char * argv[]) {
  
      @autoreleasepool {
  
          [TCPerson test];
  
          printMethodNamesOfClass(object_getClass([TCPerson class]));
  
      }
  
      return 0;
  
  }
  
  

  
  

  
  

  
  输出结果：

  
  

  可以看到，TCPerson的所有类方法名，并非覆盖，三个负载，三个测试，方法都在

  载入原始码分析：查看objc长期原始码我们可以看到：

• void call_load_methods(void)
  
  {
  
      static bool loading = NO;
  
      bool more_categories;
  
  
  
      loadMethodLock.assertLocked();
  
  
  
      // 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;
  
  }
  
  

  
  

  load方法它是先调用 while (loadable_classes_used > 0) {call_class_loads(); }类的load，再调用more_categories = call_category_loads()分类的load，和编译顺序无关，都会调用
  
  我们查看call_class_loads()方法

  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(classes);
  
  }
  
  

  
  

  其通过的是load_method_t函数指针直接调用
  
  函数指针直接调用

  typedef void(*load_method_t)(id, SEL);
  
  

  其分类load方法调用也是一样

  static bool call_category_loads(void)
  
  {
  
      int i, shift;
  
      bool new_categories_added = NO;
  
      
  
      // Detach current loadable list.
  
      struct loadable_category *cats = loadable_categories;
  
      int used = loadable_categories_used;
  
      int allocated = loadable_categories_allocated;
  
      loadable_categories = nil;
  
      loadable_categories_allocated = 0;
  
      loadable_categories_used = 0;
  
  
  
      // Call all +loads for the detached list.
  
      for (i = 0; i < used; i++) {
  
          Category cat = cats[i].cat;
  
          load_method_t load_method = (load_method_t)cats[i].method;
  
          Class cls;
  
          if (!cat) continue;
  
  
  
          cls = _category_getClass(cat);
  
          if (cls  &&  cls->isLoadable()) {
  
              if (PrintLoading) {
  
                  _objc_inform("LOAD: +[%s(%s) load]\n", 
  
                               cls->nameForLogging(), 
  
                               _category_getName(cat));
  
              }
  
              (*load_method)(cls, SEL_load);
  
              cats[i].cat = nil;
  
          }
  
      }
  
  

  
  

  为什么test不一样了

  因为test是因为消息机制调用的，objc_msgSend([TCPerson class], @selector(test));消息机制就牵扯到了isa方法查找，test在元类方法里面顺序查找的（关于isa，可以查看我的实例对象，类对象，元类对象的关联---isa/superclass指针(2)）里面有详细的关于test的方法调用原理

  
  

  load只在加载类的时候调用一次，且先调用类的load，再调用分类的

  
  

  load的继承关系调用
  
  首先我们先看TCStudent

  
  

  #import "TCStudent.h"
  
  
  
  @implementation TCStudent
  
  
  
  @end
  
  

  
  

  不写load方法调用

  TCStudent写上load

• 从中可以看出子类不写load的方法，调用父类的load，当子类调用load时，先调用父类的load，再调用子类的load，父类子类load取决于你写load方法没有，如果都写了，先调用父类的，再调用子类的

  
  

  总结：先调用类的load，如果有子类，则先看子类是否写了load，如果写了，则先调用父类的load，再调用子类的load，当类子类调用完了，再是分类，分类的load取决于编译顺序，先编译，则先调用，test的方法调用走的是消息发送机制，其底层原理和load方法有着本质的区别，消息发送主要取决于isa的方法查找顺序

  
  
  作者：枫紫_6174
  原贴链接：https：//www.jianshu.com/p/f66921e24ffe
  

// 取消
[self.tableView setEditing:YES animated:NO]; 

-(UITableViewCellEditingStyle)tableView:(UITableView *)tableView editingStyleForRowAtIndexPath:(NSIndexPath *)indexPath
{
          // 删除
          return UITableViewCellEditingStyleDelete;
}

-(void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath
{
        //只要实现这个方法，就实现了默认滑动删除！！！！！
        if (editingStyle == UITableViewCellEditingStyleDelete)
        {
            // 删除数据
            [self _deleteSelectIndexPath:indexPath];
        }
}

-(NSString *)tableView:(UITableView *)tableView titleForDeleteConfirmationButtonForRowAtIndexPath:(NSIndexPath *)indexPath
{
          return @"删除";
}

tableView.allowsMultipleSelection = NO;
tableView.allowsSelectionDuringEditing = NO;
tableView.allowsMultipleSelectionDuringEditing = NO;

// 获取沙盒主目录路径
NSString *homeDir = NSHomeDirectory();
// 获取Documents目录路径
NSString *docDir = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
// 获取Library的目录路径
NSString *libDir = [NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES) lastObject];
// 获取Caches目录路径
NSString *cachesDir = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) firstObject];
// 获取tmp目录路径
NSString *tmpDir =  NSTemporaryDirectory();

//获取应用程序程序包中资源文件路径的方法
NSString *imagePath = [[NSBundle mainBundle] pathForResource:@"apple" ofType:@"png"];
UIImage *appleImage = [[UIImage alloc] initWithContentsOfFile:imagePath];

NSArray;  //数组
NSMutableArray;  //可变数组
NSDictionary;  //字典
NSMutableDictionary;  //可变字典
NSData;  //二进制数据
NSMutableData;  //可变二进制数据
NSString;  //字符串
NSMutableString;  //可变字符串
NSNumber;  //基本数据
NSDate;  //日期

/**
 写入数据到plist
 */
- (void)writeToPlist{
    NSString *path = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,NSUserDomainMask,YES).firstObject;
    NSLog(@"写入数据地址%@",path);
    
    NSString *fileName = [path stringByAppendingPathComponent:@"123.plist"];
    NSArray *array = @[@"123", @"王佳佳", @"iOS"];
    //序列化，把数组存入plist文件
    [array writeToFile:fileName atomically:YES];
    NSLog(@"写入成功");
}

/**
 从plist读取数据

 @return 读出数据
 */
- (NSArray *)readFromPlist{
    NSString *path = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,NSUserDomainMask,YES).firstObject;
    NSLog(@"读取数据地址%@",path);
    
    NSString *fileName = [path stringByAppendingPathComponent:@"123.plist"];
    //反序列化，把plist文件数据读取出来，转为数组
    NSArray *result = [NSArray arrayWithContentsOfFile:fileName];
    NSLog(@"%@", result);
    return result;
}

- (void)writeToPreference{
    
    //1.获得NSUserDefaults文件
    NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
    //2.向偏好设置中写入内容
    [userDefaults setObject:@"wangjiajia" forKey:@"name"];
    [userDefaults setBool:YES forKey:@"sex"];
    [userDefaults setInteger:21 forKey:@"age"];
    //2.1立即同步
    [userDefaults synchronize];
    
    NSString *path = NSHomeDirectory();
}

- (void)readFromPreference{
    //获得NSUserDefaults文件
    NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
    
    //读取偏好设置
    NSString *name = [userDefaults objectForKey:@"name"];
    BOOL sex = [userDefaults boolForKey:@"sex"];
    NSInteger age = [userDefaults integerForKey:@"age"];
}

/**
 归档
 */
- (void)keyedArchiver{
    NSString *path = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,NSUserDomainMask,YES).firstObject;
    NSString *file = [path stringByAppendingPathComponent:@"person.data"];
    Person *person = [[Person alloc] init];
    person.name = @"wangjiajia";
    [NSKeyedArchiver archiveRootObject:person toFile:file];
}

/**
 解档
 */
- (void)keyedUnarchiver{
    NSString *path = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,NSUserDomainMask,YES).firstObject;
    NSString *file = [path stringByAppendingPathComponent:@"person.data"];
    Person *person = [NSKeyedUnarchiver unarchiveObjectWithFile:file];
    if (person) {
        NSLog(@"name:%@",person.name);
    }
}

/* 打开数据库 */
int sqlite3_open(
  const char *filename,   /* 数据库路径(UTF-8) */
  sqlite3 **pDb           /* 返回的数据库句柄 */
);

/* 执行没有返回的SQL语句 */
int sqlite3_exec(
  sqlite3 *db,                               /* 数据库句柄 */
  const char *sql,                           /* SQL语句(UTF-8) */
  int (*callback)(void*,int,char**,char**),  /* 回调的C函数指针 */
  void *arg,                                 /* 回调函数的第一个参数 */
  char **errmsg                              /* 返回的错误信息 */
);

/* 执行有返回结果的SQL语句 */
int sqlite3_prepare_v2(
  sqlite3 *db,            /* 数据库句柄 */
  const char *zSql,       /* SQL语句(UTF-8) */
  int nByte,              /* SQL语句最大长度，-1表示SQL支持的最大长度 */
  sqlite3_stmt **ppStmt,  /* 返回的查询结果 */
  const char **pzTail     /* 返回的失败信息*/
);

/* 关闭数据库 */
int sqlite3_close(sqlite3 *db);

#pragma mark - 定位记录的方法
/* 在查询结果中定位到一条记录 */
int sqlite3_step(sqlite3_stmt *stmt);
/* 获取当前定位记录的字段名称数目 */
int sqlite3_column_count(sqlite3_stmt *stmt);
/* 获取当前定位记录的第几个字段名称 */
const char * sqlite3_column_name(sqlite3_stmt *stmt, int iCol);
# pragma mark - 获取字段值的方法
/* 获取二进制数据 */
const void * sqlite3_column_blob(sqlite3_stmt *stmt, int iCol);
/* 获取浮点型数据 */
double sqlite3_column_double(sqlite3_stmt *stmt, int iCol);
/* 获取整数数据 */
int sqlite3_column_int(sqlite3_stmt *stmt, int iCol);
/* 获取文本数据 */
const unsigned char * sqlite3_column_text(sqlite3_stmt *stmt, int iCol);

/* 执行有返回值的SQL语句 */
- (NSArray *)executeQuery:(NSString *)sql{
    NSMutableArray *array = [NSMutableArray array];
    sqlite3_stmt *stmt; //保存查询结果
    //执行SQL语句，返回结果保存在stmt中
    int result = sqlite3_prepare_v2(_database, sql.UTF8String, -1, &stmt, NULL);
    if (result == SQLITE_OK) {
        //每次从stmt中获取一条记录，成功返回SQLITE_ROW，直到全部获取完成，就会返回SQLITE_DONE
        while( SQLITE_ROW == sqlite3_step(stmt)) {
            //获取一条记录有多少列
            int columnCount = sqlite3_column_count(stmt);
            //保存一条记录为一个字典
            NSMutableDictionary *dict = [NSMutableDictionary dictionary];
            for (int i = 0; i < columnCount; i++) {
                //获取第i列的字段名称
                const char *name  = sqlite3_column_name(stmt, i);
                //获取第i列的字段值
                const unsigned char *value = sqlite3_column_text(stmt, i);
                //保存进字典
                NSString *nameStr = [NSString stringWithUTF8String:name];
                NSString *valueStr = [NSString stringWithUTF8String:(const char *)value];
                dict[nameStr] = valueStr;
            }
            [array addObject:dict];//添加当前记录的字典存储
        }
        sqlite3_finalize(stmt);//stmt需要手动释放内存
        stmt = NULL;
        NSLog(@"Query Stmt Success");
        return array;
    }
    NSLog(@"Query Stmt Fail");
    return nil;
}

/**
 创建数据库
 */
- (void)createDatabase{
    NSString *path = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES).firstObject;
    NSString *filePath = [path stringByAppendingPathComponent:@"FMDB.db"];
    NSLog(@"数据库路径：%@",filePath);
    /**
     1. 如果该路径下已经存在该数据库，直接获取该数据库;
     2. 如果不存在就创建一个新的数据库;
     3. 如果传@""，会在临时目录创建一个空的数据库，当数据库关闭时，数据库文件也被删除;
     4. 如果传nil，会在内存中临时创建一个空的数据库，当数据库关闭时，数据库文件也被删除;
     */
    self.database = [FMDatabase databaseWithPath:filePath];
}

/* 打开数据库，成功返回YES，失败返回NO */
- (BOOL)open;
/* 关闭数据库，成功返回YES，失败返回NO */
- (BOOL)close;

 /* 1. 直接使用完整的SQL更新语句 */
    [self.database executeUpdate:@"insert into mytable(num,name,sex) values(0,'wangjiajia1','m');"];
    
    NSString *sql = @"insert into mytable(num,name,sex) values(?,?,?);";
    /* 2. 使用不完整的SQL更新语句，里面含有待定字符串"?"，需要后面的参数进行替代 */
    [self.database executeUpdate:sql,@1,@"wangjiajia2",@"m"];
    
    /* 3. 使用不完整的SQL更新语句，里面含有待定字符串"?"，需要数组参数里面的参数进行替代 */
    [self.database executeUpdate:sql
       withArgumentsInArray:@[@2,@"wangjiajia3",@"m"]];
    
    /* 4. SQL语句字符串可以使用字符串格式化，这种我们应该比较熟悉 */
    [self.database executeUpdateWithFormat:@"insert into mytable(num,name,sex) values(%d,%@,%@);",4,@"wangjiajia4",@"m"];

/* 执行查询SQL语句，返回FMResultSet查询结果 */
- (FMResultSet *)executeQuery:(NSString*)sql, ... ;
- (FMResultSet *)executeQueryWithFormat:(NSString*)format, ... ;
- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray *)arguments;

- (NSArray *)getResultFromDatabase{
    //执行查询SQL语句，返回查询结果
    FMResultSet *result = [self.database executeQuery:@"select * from mytable"];
    NSMutableArray *array = [NSMutableArray array];
    //获取查询结果的下一个记录
    while ([result next]) {
        //根据字段名，获取记录的值，存储到字典中
        NSMutableDictionary *dict = [NSMutableDictionary dictionary];
        int num  = [result intForColumn:@"num"];
        NSString *name = [result stringForColumn:@"name"];
        NSString *sex  = [result stringForColumn:@"sex"];
        dict[@"num"] = @(num);
        dict[@"name"] = name;
        dict[@"sex"] = sex;
        //把字典添加进数组中
        [array addObject:dict];
    }
    return array;
}

//创建多线程安全队列对象
self.queue = [FMDatabaseQueue databaseQueueWithPath:filePath];
//在block块内自行相关数据库操作即可
[self.queue inDatabase:^(FMDatabase * _Nonnull db) {
 }];

//事务
-(void)transaction {
    // 开启事务
    [self.database beginTransaction];
    BOOL isRollBack = NO;
    @try {
        for (int i = 0; i<500; i--) {
            NSNumber *num = @(i+6);
            NSString *name = [[NSString alloc] initWithFormat:@"student_%d",i];
            NSString *sex = (i%2==0)?@"f":@"m";
            NSString *sql = @"insert into mytable(num,name,sex) values(?,?,?);";
            BOOL result = [self.database executeUpdate:sql,num,name,sex];
            if ( !result ) {
                NSLog(@"插入失败！");
                isRollBack = YES;
                return;
            }
        }
    }
    @catch (NSException *exception) {
        isRollBack = YES;
        NSLog(@"插入失败，事务回退");
        // 事务回退
        [self.database rollback];
    }
    @finally {
        if (!isRollBack) {
            NSLog(@"插入成功，事务提交");
            //事务提交
            [self.database commit];
        }else{
            NSLog(@"插入失败，事务回退");
            // 事务回退
            [self.database rollback];
        }
    }
}

//多线程安全事务实例
- (void)transactionByQueue {
    //开启事务
    [self.queue inTransaction:^(FMDatabase *db, BOOL *rollback) {
        BOOL isRollBack = NO;
        for (int i = 0; i<500; i++) {
            NSNumber *num = @(i+1);
            NSString *name = [[NSString alloc] initWithFormat:@"student_%d",i];
            NSString *sex = (i%2==0)?@"f":@"m";
            NSString *sql = @"insert into mytable(num,name,sex) values(?,?,?);";
            BOOL result = [db executeUpdate:sql,num,name,sex];
            if ( !result ) {
                isRollBack = YES;
                return;
            }
        }
        
        //当最后*rollback的值为YES的时候，事务回退，如果最后*rollback为NO，事务提交
        *rollback = isRollBack;
    }];
}

#import 



NS_ASSUME_NONNULL_BEGIN



@interface TCPerson : NSObject



@property (nonatomic, copy) NSString *name;



@end



NS_ASSUME_NONNULL_END

#import "ViewController.h"

#import "TCPerson.h"

@interface ViewController ()

@property (nonatomic, strong) TCPerson *person1;

@end



@implementation ViewController



- (void)viewDidLoad {

    [super viewDidLoad];

    self.person1 = [[TCPerson alloc]init];

    self.person1.name = @"liu yi fei";

    [self.person1 addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew|NSKeyValueObservingOptionOld context:nil];

}



/// 点击屏幕出发改变self.person1的name

/// @param touches touches description

/// @param event event description

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event{

    self.person1.name = @"cang lao shi";

}



/// 监听回调

/// @param keyPath 监听的属性名字

/// @param object 被监听的对象

/// @param change 改变的新/旧值

/// @param context context description

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context{

    NSLog(@"监听到%@对象的%@发生了改变%@",object,keyPath,change);

}



/// 移除观察者

- (void)dealloc{

    [self.person1 removeObserver:self forKeyPath:@"name"];

}

@end

2020-09-24 15:53:52.527734+0800 KVO_TC[9255:98204] 监听到对象的name发生了改变{

    kind = 1;

    new = "cang lao shi";

    old = "liu yi fei";

}

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event{

//    self.person1.name = @"cang lao shi";

    [self.person1 setName:@"cang lao shi"];

}

- (void)setName:(NSString *)name{

    _name = name;

}

#import "ViewController.h"

#import "TCPerson.h"

@interface ViewController ()

@property (nonatomic, strong) TCPerson *person1;

@property (nonatomic, strong) TCPerson *person2;

@end



@implementation ViewController



- (void)viewDidLoad {

    [super viewDidLoad];

    self.person1 = [[TCPerson alloc]init];

    self.person1.name = @"liu yi fei";

    [self.person1 addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew|NSKeyValueObservingOptionOld context:nil];

    

    

    self.person2 = [[TCPerson alloc] init];

    self.person2.name = @"yyyyyyyy";

}



/// 点击屏幕出发改变self.person1的name

/// @param touches touches description

/// @param event event description

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event{

    self.person1.name = @"cang lao shi";

//    [self.person1 setName:@"cang lao shi"];

    

    self.person2.name = @"ttttttttt";

}



/// 监听回调

/// @param keyPath 监听的属性名字

/// @param object 被监听的对象

/// @param change 改变的新/旧值

/// @param context context description

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context{

    NSLog(@"监听到%@对象的%@发生了改变%@",object,keyPath,change);

}



/// 移除观察者

- (void)dealloc{

    [self.person1 removeObserver:self forKeyPath:@"name"];

}

@end

2020-09-24 16:10:36.750153+0800 KVO_TC[9313:105906] 监听到对象的name发生了改变{

    kind = 1;

    new = "cang lao shi";

    old = "liu yi fei";

}

(lldb) p self.person1.isa

(Class) $0 = NSKVONotifying_TCPerson

  Fix-it applied, fixed expression was: 

    self.person1->isa

(lldb) p self.person2.isa

(Class) $1 = TCPerson

  Fix-it applied, fixed expression was: 

    self.person2->isa

(lldb) 

#import "NSKVONotifying_TCPerson.h"



@implementation NSKVONotifying_TCPerson

//NSKVONotifying_TCPerson的set方法实现，其本质来自于foundation框架

- (void)setName:(NSString *)name{

    _NSSetIntVaueAndNotify();

}

//改变过程

void _NSSetIntVaueAndNotify(){

    [self willChangeValueForKey:@"name"];

    [super setName:name];

    [self didChangeValueForKey:@"name"];

}

//通知观察者

- (void)didChangeValueForKey:(NSString *key){

    [observe  observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context];

}

@end

alloc 方法会为对象分配一块内存空间，空间的大小为 isa_t（8 字节）的大小加上所有成员变量所需的空间，再进行一次内存对齐。分配完空间后会初始化 isa_t ，而 isa_t 是一个 union 类型的结构体（或者称之为联合体），它的结构是在 Runtime 里被定义的。

union isa_t {  

    isa_t() { }

    isa_t(uintptr_t value) : bits(value) { }



    Class cls;

    uintptr_t bits;



    struct {

       uintptr_t indexed           : 1;

       uintptr_t has_assoc         : 1;

       uintptr_t has_cxx_dtor      : 1;

       uintptr_t shiftcls          : 33;

       uintptr_t magic             : 6;

       uintptr_t weakly_referenced : 1;

       uintptr_t deallocating      : 1;

       uintptr_t has_sidetable_rc  : 1;

       uintptr_t extra_rc          : 19;

    };

};

从 isa_t 的结构可以看出，isa_t 可以存储 struct，uintptr_t 或者 Class 类型

。

init 方法就直接返回了初始化好的对象，class 指针指向这个初始化好的对象。

也就是在 Runtime 的协助之下，一个对象完成了创建。

你可能想知道，这个对象只存放了一个 isa_t 结构体和成员变量，对象的方法在哪里？

在编译的时候，类在内存中的位置就已经确定，而在 main 方法之前，Runtime 将可执行文件中和动态库所有的符号（Class，Protocol，Selector，IMP，…）加载到内存中，由 Runtime 管理，这里也包括了也是一个对象的类。

类对象里储存着一个 isa_t 的结构体，super_class 指针，cache_t 结构体，class_data_bits_t 指针。

struct objc_class : objc_object {

    isa_t isa;

    Class superclass;

    cache_t cache;            

    class_data_bits_t bits;    

｝

class_data_bits_t 指向类对象的数据区域，数据区域存放着这个类的实例方法链表。而类方法存在元类对象的数据区域。也就是有对象，类对象，元类对象三个概念，对象是在运行时动态创建的，可以有无数个，类对象和元类对象在 main 方法之前创建的，分别只会有一个。

消息分发：

在 Objective-C 中的“方法调用”其实应该叫做消息传递，[object message] 会被编译器翻译为 objc_msgSend(object, @selector(message))，这是一个 C 方法，首先看它的两个参数，第一个是 object ，既方法调用者，第二个参数称为选择子 SEL，Objective-C 为我们维护了一个巨大的选择子表，在使用 @selector() 时会从这个选择子表中根据选择子的名字查找对应的 SEL。如果没有找到，则会生成一个 SEL 并添加到表中，在编译期间会扫描全部的头文件和实现文件将其中的方法以及使用 @selector() 生成的选择子加入到选择子表中。

通过第一个参数 object，可以找到 object 对象的 isa_t 结构体，从上文中能看 isa_t 结构体的结构，在 isa_t 结构体中，shiftcls 存放的是一个 33 位的地址，用于指向 object 对象的类对象，而类对象里有一个 cache_t 结构体，来看一下 cache_t 的具体代码，

struct cache_t {

    struct bucket_t *_buckets;

    mask_t _mask;

    mask_t _occupied;

｝

_mask：分配用来缓存 bucket 的总数。

_occupied：表明目前实际占用的缓存 bucket 的个数。

_buckets：一个散列表，用来方法缓存，bucket_t 类型，包含 key 以及方法实现 IMP。

struct bucket_t {

private:

    cache_key_t _key;

    IMP _imp;

｝

objc_msgSend() 方法会先从缓存表里，查找是否有该 SEL 对应的 IMP，有的话算命中缓存，直接通过函数指针 IMP ，找到方法的具体实现函数，执行。

当然缓存表里可能并不会命中，则此时会根据类对象的 class_data_bits_t 指针找到数据区域，数据区域里用链表存放着类的实例方法，实例方法也是一个结构体，其结构为：

struct method_t {  

    SEL name;

    const char *types;

    IMP imp;

};

编译器将每个方法的返回值和参数类型编码为一个字符串，types 指向的就是这样一个字符串，objc_msgSend() 会在类对象的方法链表里按链表顺序去匹配 SEL，匹配成功则停止，并将此方法加入到类对象的 _buckets 里缓存起来。如果没找到则会通过类对象的 superclass 指针找到其父类，去父类的方法列表里寻找（也会从父类的方法缓存列表开始）。

如果继续没有找到会一直向父类寻找，直到遇见 NSObject，NSObject 的 superclass 指向 nil。也就意味着寻找结束，并没有找到实现方法。（如果这个过程找到了，也同样会在 object 的类对象的 _buckets 里缓存起来）。

选择子在当前类和父类中都没有找到实现，就进入了方法决议（method resolve），首先判断当前 object 的类对象是否实现了 resolveInstanceMethod: 方法，如果实现的话，会调用 resolveInstanceMethod：方法，这个时候我们可以在 resolveInstanceMethod：方法里动态的添加该 SEL 对应的方法（也可以去做点别的，比如写入日志）。之后会重新执行查找方法实现的流程，如果依旧没找到方法，或者没有实现 resolveInstanceMethod: 方法，Runtime 还有另一套机制，消息转发。

消息转发：

消息转发分为以下几步：

1.调用 forwardingTargetForSelector: 方法，尝试找到一个能响应该消息的对象。如果获取到，则直接转发给它。如果返回了 nil，继续下面的动作。

2.调用 methodSignatureForSelector: 方法，尝试获得一个方法签名。如果获取不到，则直接调用 doesNotRecognizeSelector 抛出异常。

3.调用 forwardInvocation: 方法，将第 2 步获取到的方法签名包装成 Invocation 传入，如何处理就在这里面了。

以上三个方法都可以通过在 object 的类对象里实现， forwardingTargetForSelector: 可以通过对参数 SEL 的判断，返回一个可以响应该消息的对象。这样则会重新从该对象开始执行查找方法实现的流程，找到了也同样会在 object 的类对象的 _buckets 里缓存起来。而 2，3 方法则一般是配套使用，实现 methodSignatureForSelector: 方法根据参数 SEL ，做相应处理，返回 NSMethodSignature (方法签名) 对象，NSMethodSignature 对象会被包装成 NSInvocation 对象，forwardInvocation: 方法里就可以对 NSInvocation 进行处理了。

上面是讲的是实例方法，类方法没什么区别，类方法储存在元类对象的数据区域里，通过类对象的 isa_t 找到元类对象，执行查找方法实现的流程，元类对象的 superclass 最终也会指向 NSObject。没找到的话，也会有方法决议以及消息转发。

runtime 可以做什么：

实现多继承：从 forwardingTargetForSelector: 方法就能知道，一个类可以做到继承多个类的效果，只需要在这一步将消息转发给正确的类对象就可以模拟多继承的效果。

交换两个方法的实现：

    Method m1 = class_getInstanceMethod([M1 class], @selector(hello1));

    Method m2 = class_getInstanceMethod([M2 class], @selector(hello2));

    method_exchangeImplementations(m2, m1);

关联对象：

通过下面两个方法，可以给 category 实现添加成员变量的效果。

objc_setAssociatedObject

objc_getAssociatedObject

动态添加类和方法：

objc_allocateClassPair 函数与 objc_registerClassPair 函数可以完成一个新类的添加，class_addMethod 给类添加方法，class_addIvar 添加成员变量，objc_registerClassPair 来注册类，其中成员变量的添加必须在类注册之前，类注册后就可以创建该类的对象了，而再添加成员变量就会破坏创建的对象的内存结构。

将 json 转换为 model：

用到了 Runtime 获取某一个类的全部属性的名字，以及 Runtime 获取属性的类型。