• OC语言特性


    Category

    • 你用分类都做了哪些事情?
      • 声明私有方法
      • 分解体积庞大的类文件
      • 把Framework的私有方法公开
    • 特点
      • 在运行时决议,也就是在编译时并没有把Category中声明的内容添加到宿主类中,而是在运行的时候通过runtime将添加的方法添加到宿主类上面
      • 可以为系统添加分类
    • 分类中可以添加哪些内容?
      • 实例方法
      • 类方法
      • 协议
      • 属性
    • Category结构
    struct category_t {
        const char *name;	//分类名称
        classref_t cls;		//分类所属的宿主类
        struct method_list_t *instanceMethods;  //实例方法列表
        struct method_list_t *classMethods;  //类方法列表
        struct protocol_list_t *protocols;	//协议
        struct property_list_t *instanceProperties; //实例属性列表
        // Fields below this point are not always present on disk.
        struct property_list_t *_classProperties;
    
        method_list_t *methodsForMeta(bool isMeta) {
            if (isMeta) return classMethods;
            else return instanceMethods;
        }
    
        property_list_t *propertiesForMeta(bool isMeta, struct header_info *hi);
    };
    
    
    • Category方法添加源码
    // Attach method lists and properties and protocols from categories to a class.
    // Assumes the categories in cats are all loaded and sorted by load order, 
    // oldest categories first.
    static void 
    attachCategories(Class cls, category_list *cats, bool flush_caches)
    {
        if (!cats) return;
        if (PrintReplacedMethods) printReplacements(cls, cats);
    
        bool isMeta = cls->isMetaClass();
    
        // fixme rearrange to remove these intermediate allocations
        /*二维数组
         
         */
        method_list_t **mlists = (method_list_t **)
            malloc(cats->count * sizeof(*mlists));
        property_list_t **proplists = (property_list_t **)
            malloc(cats->count * sizeof(*proplists));
        protocol_list_t **protolists = (protocol_list_t **)
            malloc(cats->count * sizeof(*protolists));
    
        // Count backwards through cats to get newest categories first
        int mcount = 0;     //方法
        int propcount = 0;
        int protocount = 0;
        int i = cats->count;    //宿主分类的总数
        bool fromBundle = NO;
        while (i--) {   //这里是倒叙遍历,最先访问最后编译的分类,所以多个分类添加的同名方法最后编译的最终生效
            //获取一个分类
            auto& entry = cats->list[i];
            //获取该分类的方法列表
            method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
            if (mlist) {
                //最后编译的分类最先添加到分类数组中
                mlists[mcount++] = mlist;
                fromBundle |= entry.hi->isBundle();
            }
    
            property_list_t *proplist = 
                entry.cat->propertiesForMeta(isMeta, entry.hi);
            if (proplist) {
                proplists[propcount++] = proplist;
            }
    
            protocol_list_t *protolist = entry.cat->protocols;
            if (protolist) {
                protolists[protocount++] = protolist;
            }
        }
    
        //获取随著类当中的rw数据,其中包含宿主类的方法列表信息
        auto rw = cls->data();
    
        //主要针对分类中有关于内存管理想干方法情况下的一些特殊处理
        prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
        
        /*
         rw代表类
         methods代表类的方法列表
         attachLists 方法的含义是 将含有没count个元素的mlists拼接到rw的methods上
         */
        rw->methods.attachLists(mlists, mcount);
        free(mlists);
        if (flush_caches  &&  mcount > 0) flushCaches(cls);
     
        rw->properties.attachLists(proplists, propcount);
        free(proplists);
    
        rw->protocols.attachLists(protolists, protocount);
        free(protolists);
    }
    
    

    关联对象

    • 能否给分类添加“成员变量”?

      • 能通过关联对象的方式给分类添加成员变量
      //设定一个value值,通过key设定和value的映射关系,通过policy策略关联到对象上面
      objc_setAssociatedObject(id _Nonnull object, const void * _Nonnull key,
                           id _Nullable value, objc_AssociationPolicy policy)
      
      //根据指定的key到object中获取和key相对应的关联值
      objc_getAssociatedObject(id _Nonnull object, const void * _Nonnull key)
      
      //根据指定对象移除它所有的关联对象
      objc_removeAssociatedObjects(id _Nonnull object)
      
      • 通过关联对象为分类添加的"成员变量"由AssociationsManager统一管理全部存储在AssociationsHashMap中,所有类的关联对象都存在同一个全局容器中
      void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
      // retain the new value (if any) outside the lock.
      ObjcAssociation old_association(0, nil);
      //根据policy的值对value进行copy或者retain操作
      id new_value = value ? acquireValue(value, policy) : nil;
      {
          //关联对象管理类,C++实现的一个类
          AssociationsManager manager;
          
          //获取其维护的一个HashMap
          AssociationsHashMap &associations(manager.associations());
          disguised_ptr_t disguised_object = DISGUISE(object);
          if (new_value) {
              // break any existing association.
              //根据对象指针查找对应的一个ObjectAssociationMap结构的map
              AssociationsHashMap::iterator i = associations.find(disguised_object);
              if (i != associations.end()) {
                  // secondary table exists
                  ObjectAssociationMap *refs = i->second;
                  ObjectAssociationMap::iterator j = refs->find(key);
                  if (j != refs->end()) {
                      old_association = j->second;
                      j->second = ObjcAssociation(policy, new_value);
                  } else {
                      (*refs)[key] = ObjcAssociation(policy, new_value);
                  }
              } else {
                  //没找到关联值的时候进行添加
                  // create the new association (first time).
                  ObjectAssociationMap *refs = new ObjectAssociationMap;
                  associations[disguised_object] = refs;
                  (*refs)[key] = ObjcAssociation(policy, new_value);
                  object->setHasAssociatedObjects();
              }
          } else {
              //当value传为空时则对该关联进行擦除操作
              // setting the association to nil breaks the association.
              AssociationsHashMap::iterator i = associations.find(disguised_object);
              if (i !=  associations.end()) {
                  ObjectAssociationMap *refs = i->second;
                  ObjectAssociationMap::iterator j = refs->find(key);
                  if (j != refs->end()) {
                      old_association = j->second;
                      refs->erase(j); //擦除操作
                  }
              }
          }
      }
      // release the old value (outside of the lock).
      if (old_association.hasValue()) ReleaseValue()(old_association);
      

    }
    ```

    扩展(Extension)

    • 作用
      • 声明私有属性,可以不被子类继承
      • 声明私有方法
      • 声明私有成员变量
    • 特点
      • 编译时决议
      • 只以声明的形式存在,多数情况下寄生于宿主类的.m中来进行声明方法的实现
      • 不能为系统类添加扩展

    代理(Delegate)

    • 准确的说是一种设计模式

    • iOS当中以@protocol形式体现

    • 传递方式一对一

    • 怎么声明必须实现方法和选择实现方法

      • 被标记为@required为必须实现的
      • 被标记为@optional为可选实现的
    • 容易出现循环引用,所以委托方需要通过weak关键字来弱化引用

    通知(NSNotification)

    • 通知是使用观察者模式来实现、用于跨层传递消息的机制
    • 通知和代理的区别
      • 代理是通过代理模式实现的,通知是通过观察者模式实现的
      • 代理是一对一,通知是一对多
    • 通知的实现流程
      • 发送者将发送的消息发送到通知中心
      • 通知中心广播给观察者
    • 通知的实现机制(代码未开源,猜测)
      • 底层应该维护一个Map表来存储注册的通知,同事每个通知下面设有观察者列表,当收到消息后则给观察者列表中的观察者发送消息

    KVO

    • Key-value observing的缩写
    • 是OC对观察者设计模式的又一实现
    • Apple使用了isa混写(isa-swizzling)来实现KVO(派生出一个名为NSKVONotifying_(ObjName)的子类并重写其setter方法)
    • KVO触发的问题
      • 通过外部直接修改属性可能(比如属性名设置isAge,通过key=age进行kvc设置)可以触发KVO监听方法(调动setter方法)
      • 通过KVC修改也可以触发KVO的回调
      • 通过直接修改成员变量无法触发KVO监听,需手动添加监听
      //直接为成员变量赋值
        [self willChangeValueForKey:@"value"];
        _value += 1;
        [self didChangeValueForKey:@"value"];
    

    KVC(键值编码技术)

    • Key-value coding的缩写
    - (void)setValue:(nullable id)value forKey:(NSString *)key;
    
    - (nullable id)valueForKey:(NSString *)key;
    
    • 通过键值编码技术可以修改对象同名成员变量的值,其中key是没有任何限制的,在外界可以通过key进行私有变量的修改,破坏了面向对象的思想方法(把对象行为属性结合为一个整体,隐藏内部实现,吧不想告诉别人的东西隐藏起来)
    • KVC调用流程
      • 若存set(key)的方法则优先调用该方法
      • 如果不存在set(key)方法,KVC机制会检查+ (BOOL)accessInstanceVariablesDirectly方法有没有返回YES,如果返回yes则按照会按照_key,_iskey,key,iskey的顺序搜索成员变量,如果返回NO则调用- (void)setValue:(id)value forUndefinedKey:(NSString *)key方法抛出异常
    // 如果开发者想让这个类禁用KVC里,那么重写+ (BOOL)accessInstanceVariablesDirectly方法让其返回NO即可,这样的话如果KVC没有找到set<Key>:属性名时,会直接用setValue:forUndefinedKey:方法。如果返回YES则按照会按照_key,_iskey,key,iskey的顺序搜索成员变量
    
    + (BOOL)accessInstanceVariablesDirectly
    {
        return YES;
    }
    
    //setValue:forKey:通过_key,_iskey,key,iskey的顺序搜索成员变量查找仍未找到对应的key时调用该方法
    - (void)setValue:(id)value forUndefinedKey:(NSString *)key
    {
        NSLog(@"%@", key);
    }
    
    //valueForKey:通过_key,_iskey,key,iskey的顺序搜索成员变量查找仍未找到对应的key时调用该方法
    - (id)valueForUndefinedKey:(NSString *)key
    {
        NSLog(@"%@", key);
        return [super valueForUndefinedKey:key];
    }
    

    属性关键字

    • 原子性
      • atomic修饰数组时对数组进行赋值和获取时是安全的,但是对数组进行增删是不在atomic责任之内的
      • nonmatic
    • 引用计数
      • retain/strong
      • assign/unsafe_unetained
      • weak
      • copy
      • assign
    • assign和weak区别
      • assign
        • assign可以修饰基本数据类型,如int,BOOL等;
        • 修饰对象类型时,不改变其引用计数
        • 会产生垂悬指针(assign修饰对象释放后指针会继续指向原地址,如果继续访问可能获取原对象造成异常)
      • weak
        • 不改变被修饰对象的引用计数
        • 所指对象在被释放后会自动置nil
      • assign既可以修饰对象又可以修饰基本数据类型,weak只能修饰对象
      • assign修饰对象释放后指针会继续指向原地址,而weak是置为nil的

    OC语言笔试题

    • MRC下如何重写retain修饰变量的setter方法?
    @property (nonatomic, retain) id obj;
    
    - (void)setName:(id)obj
    {
        if (_obj != obj) {
            [_obj release];
            _obj = [obj retain];
        }
    }
    
    
  • 相关阅读:
    第七单元
    第六单元
    第五单元
    第四单元
    第三章
    第二单元
    第一单元
    单词
    机器学习和模式识别的区别
    TODO-项目
  • 原文地址:https://www.cnblogs.com/GoodmorningMr/p/11536076.html
Copyright © 2020-2023  润新知