2023最新高级难度Objective-C面试题,包含答案。刷题必备！记录一下。

标签：面试题 对象 使用 实现 内存 2023 Objective 方法

好记性不如烂笔头

内容来自 面试宝典-高级难度Objective-C面试题合集

问: 请解释一下Objective-C中的“Method Swizzling”（方法混淆）是什么？它的原理和使用场景是什么？

Method Swizzling是Objective-C中的一个特性，它允许你在一个运行时环境中交换两个方法的实现。这意味着你可以替换某个对象类中指定方法的实现，使得当这个方法被调用时，实际上执行的是另一个方法。

原理

在Objective-C中，每个类都有一个与之关联的方法列表，其中包含了该类的所有实例方法和类方法。这些方法的实现是在运行时动态绑定的，这意味着即使编译时不知道具体的实现代码，也可以发送消息给对象。

Method Swizzling的工作原理是利用Objective-C的运行时特性来修改这个方法列表，将一个方法的SEL（选择器）指向另一个方法的IMP（实现）。这样，当你调用原方法时，实际上是执行了被交换的方法。

使用场景

Method Swizzling通常用于以下几种场景：

1. 监控和日志：通过交换方法实现，可以在不修改原有代码的情况下，对特定方法的调用进行记录或监控，以便于调试或分析应用程序的行为。

2. 功能扩展：可以使用Method Swizzling为现有类添加额外的功能，而无需创建子类或更改原始代码。

3. API Hooking：在某些情况下，可能需要在系统提供的方法上插入自定义代码，以实现特殊的逻辑或者修改其行为。

4. 性能优化：例如，如果你发现某个方法的实现效率低下，可以使用Method Swizzling替换为一个更高效的版本。

示例

下面是一个简单的Method Swizzling示例，它交换了-[UIViewController viewDidAppear:]和-[MyViewController my_viewDidAppear:]两个方法的实现：

#import <objc/runtime.h>

@implementation UIViewController (Swizzle)

+ (void)load {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        Method originalMethod = class_getInstanceMethod(self, @selector(viewDidAppear:));
        Method swizzledMethod = class_getInstanceMethod(self, @selector(my_viewDidAppear:));
        
        BOOL didAddMethod = class_addMethod(self, @selector(viewDidAppear:), method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod));
        
        if (didAddMethod) {
            class_replaceMethod(self, @selector(my_viewDidAppear:), method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod));
        } else {
            method_exchangeImplementations(originalMethod, swizzledMethod);
        }
    });
}

- (void)my_viewDidAppear:(BOOL)animated {
    [self my_viewDidAppear:animated];
    
    // 这里插入你的自定义代码
    NSLog(@"View appeared: %@", NSStringFromClass([self class]));
}

@end

在这个例子中，我们首先获取了viewDidAppear:和my_viewDidAppear:两个方法的SEL和IMP，然后使用class_addMethod和class_replaceMethod来确定是否需要交换这两个方法的实现。如果需要，则使用method_exchangeImplementations来进行交换。

请注意，虽然Method Swizzling是一种强大的工具，但在实际使用时要谨慎，因为它可能会引入难以预料的问题，如内存泄漏、线程安全问题等。因此，只有在必要时才应使用这种方法，并确保对其行为有充分的理解。

问: Objective-C中的“Associated Objects”是如何工作的？请解释它的实现原理和作用。

Objective-C中的“Associated Objects”（关联对象）是一种在运行时向对象添加额外属性的方法。虽然Objective-C不支持直接给已有的类添加实例变量，但通过关联对象，可以动态地将任意键值对附加到任何对象上，从而实现类似功能。

实现原理

Objective-C的关联对象是通过objc_setAssociatedObject、objc_getAssociatedObject和objc_removeAssociatedObjects等函数来操作的。这些函数位于<objc/runtime.h>头文件中，它们与Objective-C的运行时系统紧密相关。

当你调用objc_setAssociatedObject函数时，它会在目标对象内部创建一个关联引用表（Association Map），并将提供的键值对存储在这个表中。这个表是一个哈希表，键通常是void *类型的指针，用于标识关联的对象；值可以是任何类型的数据，包括其他对象或基本数据类型。

使用场景

关联对象在以下场景中特别有用：

1. 分类（Category）：分类是一种向现有类添加方法的方式，但是无法添加实例变量。通过使用关联对象，可以在分类中为类添加新的属性。

2. 避免继承：如果你不想因为添加少量属性而创建一个新的子类，可以使用关联对象。

3. 跨模块扩展：当你的代码不能访问某个类的源码，但仍需要为其添加属性时，可以使用关联对象。

4. 临时存储数据：有时你可能需要在对象生命周期内临时保存一些数据，但又不想为此创建一个单独的成员变量。在这种情况下，可以使用关联对象。

示例

下面是一个使用关联对象的例子，展示了如何在一个分类中添加一个属性：

#import <objc/runtime.h>

@interface NSObject (MyCategory)

@property (nonatomic, strong) NSString *myProperty;

@end

@implementation NSObject (MyCategory)

- (NSString *)myProperty {
    return objc_getAssociatedObject(self, _cmd);
}

- (void)setMyProperty:(NSString *)myProperty {
    objc_setAssociatedObject(self, @selector(myProperty), myProperty, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

@end

在这个例子中，我们定义了一个名为myProperty的属性，并在getter和setter方法中使用了objc_getAssociatedObject和objc_setAssociatedObject函数。这样，即使NSObject类本身没有myProperty这个属性，我们也可以像普通属性一样使用它。

请注意，关联对象不是线程安全的，因此在多线程环境中使用时要确保正确同步。此外，由于关联对象是在运行时动态分配的，所以可能会增加内存开销。在实际使用时应权衡其利弊。

问: 什么是Objective-C中的“Message Forwarding”（消息转发）？请解释它的实现机制和使用方式。

Objective-C中的“Message Forwarding”（消息转发）是一个运行时特性，它允许一个对象在接收到无法处理的消息时，将该消息转发给其他对象来处理。这种机制使得程序能够更加灵活地响应未知的消息，并且可以用来实现一些高级的设计模式和功能。

实现机制：

当一个对象接收到一条不能正常处理的消息时，它的消息转发过程会经历以下几个阶段：

1. 动态方法解析：

   • 这是消息转发的第一步，如果接收者没有实现消息所对应的方法，但在类中添加这个方法就能解决问题的话，那么运行时系统就会提供一次机会让你尝试这样做。
   • 这个步骤可以通过重写+resolveInstanceMethod:或+resolveClassMethod:这两个类方法来实现。

2. 快速转发：

   • 如果动态方法解析失败，或者你选择不进行动态方法解析，接下来就是快速转发。
   • 快速转发检查接收者是否实现了-forwardingTargetForSelector:方法。如果有，就调用这个方法，并返回一个新的对象来处理这条消息。如果没有，就进入下一个阶段。

3. 标准转发：

   • 在快速转发失败后，消息的转发过程进入到标准转发阶段。
   • 标准转发要求我们实现-methodSignatureForSelector:和-forwardInvocation:两个方法。
   • methodSignatureForSelector:需要返回一个描述要转发的消息的签名的对象，用于创建一个NSInvocation对象。
   • forwardInvocation:则负责接收NSInvocation对象，并将其转发给另一个对象去执行。

使用方式：

使用消息转发主要有两种情况：

1. 为未实现的方法提供备用处理器：

   • 当某个对象收到了一个尚未实现的方法调用时，你可以通过实现forwardInvocation:方法来转发这个调用到另一个对象上，从而避免程序崩溃。

2. 模拟多继承：

   • Objective-C只支持单继承，但有时我们需要在一个子类中同时使用多个父类的功能。这时，我们可以利用消息转发来达到类似的效果。具体做法是在子类中定义一个代理属性，然后在forwardInvocation:方法中将消息转发给这个代理对象。

通过消息转发，Objective-C提供了很大的灵活性，使得开发者可以在运行时动态地改变对象的行为，这对于处理复杂的应用场景非常有帮助。

问: Objective-C中的“Block”是如何实现的？请解释一下Block的内部结构和使用注意事项。

Objective-C中的“Block”是一种特殊的数据类型，可以捕获其定义时的上下文变量，并在将来某个时间点执行一段代码。Block类似于C++的lambda表达式或函数对象，以及JavaScript中的闭包。

Block的内部结构：

Block的本质是一个结构体，包含三个部分：描述block的元数据、引用的对象和实际的实现代码。

1. 描述block的元数据：

   • 包括了block的大小、签名（返回值类型和参数列表）以及其他一些信息。

2. 引用的对象：

   • 如果block捕获了外部的局部变量或者全局变量，那么这些变量就会被复制到block结构体中，形成对这些变量的一个强引用。

3. 实际的实现代码：

   • block的实际实现代码是在编译时生成的，它通常位于一个单独的函数中，这个函数包含了block定义时的那段代码。

Block的使用注意事项：

1. 判空处理：

   • 在使用block之前，需要对其进行判空处理，以防止因为空指针导致的程序崩溃。

2. 内存管理：

   • 在MRC（手动引用计数）环境下，block作为成员变量或者属性时，需要进行copy操作，将栈上的block拷贝到堆上，以防止block随着栈内存的释放而被销毁。
   • 使用完block后，最好将其指针赋为NULL，以避免野指针错误。在MRC环境下，还要记得release掉block对象。

3. 循环引用：

   • 如果block中使用了self或者其他强引用的对象，可能会造成循环引用，从而导致内存泄露。为了避免这种情况，可以在block中使用__weak来声明对self的弱引用。

4. 内存对齐：

   • 由于block内部结构的特殊性，它在内存中是按照特定的字节边界对齐的，因此在分配和释放block时需要注意这一点。

5. 访问控制：

   • Block默认情况下可以访问其所在作用域内的所有变量，包括静态变量和局部变量。如果希望限制block的访问权限，可以通过@private、@protected或@public关键字来进行修饰。

通过理解Block的内部结构和使用注意事项，开发者可以更加高效地使用Block来编写出简洁、高效的Objective-C代码。

问: 请解释一下Objective-C中的“Category”（分类）是如何工作的？它的实现原理和使用场景是什么？

Objective-C中的“Category”（分类）是一种为已存在的类添加新方法的方式。它允许我们在不修改原有类的源代码的情况下，向类中动态地添加新的功能。这种方式非常适用于组织代码、模块化开发以及扩展第三方库。

Category的工作原理：

当编译器遇到一个Category声明时，它会生成一个新的结构体，这个结构体包含了Category的方法列表和属性列表。在运行时，这些信息会被合并到原始类的信息中去。这意味着当你通过Category给一个类添加了一个新的方法后，你可以像调用该类原本就有的方法一样来调用这个新方法。

具体来说，Category的实现原理包括以下几个步骤：

1. 编译：

   • 编译器将Category的源文件编译成目标文件，并将其中的方法信息存储在一个特殊的结构体中。

2. 链接：

   • 链接阶段会把所有与主程序相关的对象文件（包括Category的目标文件）组合起来，形成可执行文件。

3. 加载：

   • 当程序运行并加载时，运行时系统会读取类的信息，并将Category的信息合并到原始类的信息中去。

4. 方法查找：

   • 当你发送一个消息给某个对象时，运行时系统会先在接收者的类和其父类中查找对应的方法。如果找不到，它还会继续在Category中查找。这就是为什么Category中的方法可以被正常调用的原因。

Category的使用场景：

1. 组织代码：

   • 通过Category，我们可以将一个大型的类分解成多个小的逻辑块，每个逻辑块都包含一组相关的方法。这样可以使代码更加清晰、易于维护。

2. 模块化开发：

   • 在团队协作中，不同的开发者可以分别负责不同的Category，从而实现模块化开发。

3. 扩展第三方库：

   • 如果你想给一个第三方库的类添加一些额外的功能，但又不想直接修改库的源代码，这时就可以使用Category来实现。

4. 避免命名冲突：

   • 如果两个类具有相同的方法名，但它们的实现是完全不同的，那么可以通过Category来区分这两个方法，避免命名冲突。

需要注意的是，虽然Category可以用来添加实例方法和类方法，但它不能添加实例变量。如果你想为一个类添加实例变量，你需要创建一个子类。此外，Category的使用也有一些限制，比如不能覆写原有的方法（尽管可以定义同名的新方法，但这可能导致问题），也不能改变原有的方法实现。

问: Objective-C中的“Automatic Reference Counting”（ARC）是如何实现的？请解释它的原理和优缺点。

Objective-C中的“Automatic Reference Counting”（ARC）是一种自动内存管理机制，它在编译时插入必要的retain、release和autorelease语句来管理对象的生命周期。这样，程序员就不需要手动进行内存管理，大大降低了程序中出现内存泄漏和悬垂指针的风险。

ARC的工作原理：

1. 编译器插入引用计数操作：

   • 当你创建一个对象或对一个对象赋值时，编译器会为你插入一条retain语句，增加该对象的引用计数。
   • 当你不再使用一个对象时，编译器会插入一条release或autorelease语句，减少该对象的引用计数。
   • 当一个对象的引用计数变为0时，它会被自动销毁，并释放其占用的内存。

2. 运行时系统跟踪引用计数：

   • 运行时系统负责维护每个对象的引用计数，并在适当的时机调用对象的dealloc方法来释放对象。

3. 弱引用和循环引用处理：

   • 为了防止循环引用导致内存泄露，ARC引入了__weak关键字来声明弱引用，当被引用的对象被销毁时，弱引用会被自动设为nil。
   • 对于MRC环境下的__block变量，在ARC环境下也有了对应的处理方式。

ARC的优点：

1. 降低内存管理的复杂性：

   • ARC消除了手动管理内存的需要，使得程序员可以更专注于业务逻辑的实现。

2. 减少错误：

   • ARC通过编译时检查，可以在编译阶段发现一些常见的内存管理错误，比如忘记释放对象或者过早地释放对象。

3. 提高性能：

   • ARC通常比手动管理内存更高效，因为它是由编译器在编译时插入适当的内存管理代码，而不是由程序员在运行时手动调用内存管理函数。

ARC的缺点：

1. 学习成本：

   • 尽管ARC简化了内存管理，但程序员仍然需要理解基本的内存管理概念，才能正确使用ARC。

2. 难以调试：

   • 如果ARC的行为与预期不符，可能需要深入理解ARC的工作原理才能找到问题所在。

3. 不支持某些高级内存管理技术：

   • 例如，ARC不支持手动控制对象的生命周期，这对于一些高级的内存管理技巧是不利的。

4. 可能导致意外的内存增长：

   • 如果程序设计不当，可能会因为过度依赖ARC而导致内存持续增长，特别是在循环引用的情况下。

总的来说，ARC是一个强大的工具，可以帮助开发者编写出更加安全、高效的Objective-C代码。然而，要充分利用ARC的优势，还需要对内存管理有深入的理解和实践。

问: 什么是Objective-C中的“Method Swizzling”（方法交换）？请解释它的实现原理和常见应用场景。

Objective-C中的“Method Swizzling”（方法交换）是一种运行时技术，它允许在运行时动态地改变一个选择器所对应的方法实现。通过这种方法，可以替换类中某个方法的实现，而无需直接修改类的源代码。

Method Swizzling的实现原理：

1. 获取原始方法：

   • 使用class_getInstanceMethod()或class_getClassMethod()函数来获取要被替换的方法的指针。

2. 获取新方法：

   • 使用method_getImplementation()和method_getTypeEncoding()函数来获取新的方法实现和类型编码。

3. 交换方法实现：

   • 使用method_exchangeImplementations()函数将原始方法和新方法的实现进行交换。

4. 执行新的方法：

   • 当再次调用这个方法时，实际上执行的是已经被交换到原来位置的新方法。

5. 恢复原方法：

   • 在适当的时候，可以通过重新调用method_exchangeImplementations()来恢复原始方法的实现。

Method Swizzling的应用场景：

1. 日志、统计和监控：

   • 通过替换方法的实现，可以在每个方法执行前后添加日志记录、性能统计或者异常监控等操作。

2. 功能扩展和插件化开发：

   • 可以在不修改原有代码的情况下，为系统框架或者第三方库的功能添加额外的逻辑。

3. Hook机制：

   • 对于某些特定的行为或者事件，可以使用Method Swizzling来进行拦截和处理。

4. 单元测试：

   • 在测试环境中，可以使用Method Swizzling来替换系统的某些行为，以便更好地控制测试环境。

5. 安全防护：

   • 通过替换敏感方法的实现，可以增加一些安全检查或者权限控制。

需要注意的是，Method Swizzling是一把双刃剑，如果使用不当，可能会导致难以预料的问题，比如影响程序的稳定性和可维护性。因此，在使用Method Swizzling时需要谨慎，并确保正确理解和掌握它的实现原理和适用范围。

问: Objective-C中的“Key-Value Observing”（KVO）是如何实现的？请解释一下KVO的原理和使用方式。

Objective-C中的“Key-Value Observing”（KVO）是一种实现对象属性改变时自动通知其他对象的技术。它通过动态地修改类的结构来实现。

KVO的实现原理：

1. 生成子类：

   • 当一个对象注册为观察者并开始监听另一个对象的属性时，KVO会在运行时为被观察的对象动态地生成一个子类。

2. 重写setter方法：

   • 在生成的子类中，KVO会重写被观察属性的setter方法。这个新的setter方法在设置新值之前和之后都会调用willChangeValueForKey:和didChangeValueForKey:这两个方法，从而触发通知机制。

3. 添加观察者的信息：

   • KVO还会在被观察对象的内部存储一份观察者的信息，包括观察者对象、要观察的键以及通知选项等。

4. 发送通知：

   • 当被观察对象的属性发生变化时，KVO通过上述重写的setter方法发出通知，通知对应的观察者对象。

5. 执行观察者的回调：

   • 观察者接收到通知后，会执行其在注册观察时提供的回调方法，即observeValueForKeyPath:ofObject:change:context:。

KVO的使用方式：

1. 注册观察者：

   • 使用-addObserver:forKeyPath:options:context:方法将观察者对象添加到被观察对象上，并指定要观察的属性键路径、通知选项以及上下文信息。

2. 实现回调方法：

   • 在观察者对象中实现observeValueForKeyPath:ofObject:change:context:方法，该方法会在被观察对象的属性发生改变时被调用。

3. 移除观察者：

   • 当不再需要观察时，可以调用-removeObserver:forKeyPath:或-removeObserver:forKeyPath:context:方法从被观察对象中移除观察者。

需要注意的是，KVO只能用于观察Objective-C对象的属性，不能直接观察基本数据类型的变量。另外，KVO依赖于KVC（Key-Value Coding），所以在使用KVO之前，必须确保被观察对象遵循了NSKeyValueCoding协议。

问: 请解释一下Objective-C中的“Method Signature”（方法签名）是什么？如何使用它进行动态方法调用？

Objective-C中的“Method Signature”（方法签名）是对一个方法的描述，它包含了方法名、返回值类型和参数类型等信息。在Objective-C运行时系统中，方法签名是一个重要的概念，因为它被用来决定如何调用一个方法以及传递什么样的参数。

方法签名的组成部分：

1. 方法的选择器：

   • 也就是方法名，用于唯一地标识一个方法。

2. 返回值类型编码：

   • 表示方法返回值的数据类型，例如@表示对象，i表示整型，d表示双精度浮点型等。

3. 参数类型编码列表：

   • 每个参数都有一个相应的类型编码，这些编码按照参数顺序排列在一起。

使用方法签名进行动态方法调用：

在Objective-C中，我们可以使用NSInvocation类来实现动态方法调用。NSInvocation是一个封装了消息发送的对象，它可以保存目标对象、选择器以及所有参数，并且可以在任何时候发送这个消息。

以下是使用方法签名进行动态方法调用的基本步骤：

1. 创建方法签名：

   • 使用+ (NSMethodSignature *)signatureWithObjCTypes:(const char *)types;方法，传入类型编码字符串来创建一个方法签名对象。

2. 创建NSInvocation实例：

   • 使用- (instancetype)initWithTarget:(id)target selector:(SEL)aSelector;初始化一个NSInvocation实例，指定目标对象和要调用的方法。

3. 设置参数：

   • 使用- (void)setArgument:(const void *)argumentLocation atIndex:(NSInteger)idx;方法，依次设置每个参数的值。

4. 执行调用：

   • 调用- (void)invoke;或- (void)invokeWithTarget:(id)target;来执行方法调用。

5. 获取返回值：

   • 如果方法有返回值，可以使用- (void)getReturnValue:(void *)retLoc;方法来获取返回值。

通过这种方法，我们可以根据需要动态地调用任何方法，而无需在编译时就知道所有的方法和参数。这对于一些复杂的运行时操作非常有用，比如反射和插件化开发。

问: Objective-C中的“NSProxy”是什么？它的作用和使用场景是什么？请举例说明。

Objective-C中的“NSProxy”是一个抽象类，它定义了一种对象，这种对象可以作为其他对象的代理。NSProxy通常被用来实现一些高级的设计模式，比如远程对象、延迟加载和伪多继承等。

NSProxy的作用：

1. 充当其他对象的代理：

   • NSProxy对象可以在接收到消息时，将其转发给其他的对象来处理。

2. 实现复杂的运行时行为：

   • 通过重写-forwardInvocation:方法，NSProxy对象可以自定义如何处理接收到的消息，包括修改参数、执行额外的操作或者改变调用链路等。

3. 支持非NSObject类型的对象：

   • 尽管NSProxy本身是NSObject的子类，但它可以代理任何遵循了协议的对象，包括那些并非NSObject子类的对象。

NSProxy的使用场景：

1. 远程对象：

   • 当需要跨进程或者跨网络调用一个对象的方法时，可以创建一个NSProxy对象作为远程对象的代理，将消息转发到远程端，并等待响应。

2. 延迟加载：

   • 如果某个对象的初始化过程比较耗时，可以通过NSProxy先创建一个代理对象，在真正需要这个对象时再进行初始化。

3. 伪多继承：

   • Objective-C不支持多继承，但通过NSProxy可以模拟多继承的效果。例如，我们可以创建一个NSProxy子类，让它同时代理多个不同的对象，并在-forwardInvocation:中根据选择器决定将消息转发给哪个对象。

示例说明：

以下是一个简单的例子，展示了如何使用NSProxy来实现伪多继承：

// 假设我们有两个类，Car和Bike，它们都实现了drive方法
@interface Car : NSObject
- (void)drive;
@end

@implementation Car
- (void)drive {
    NSLog(@"Driving a car");
}
@end

@interface Bike : NSObject
- (void)drive;
@end

@implementation Bike
- (void)drive {
    NSLog(@"Riding a bike");
}
@end

// 创建一个NSProxy子类，并实现forwardInvocation:方法
@interface MultiVehicle : NSProxy
@property (nonatomic, strong) Car *car;
@property (nonatomic, strong) Bike *bike;
@end

@implementation MultiVehicle

- (instancetype)initWithCar:(Car *)car andBike:(Bike *)bike {
    self = [super init];
    if (self) {
        _car = car;
        _bike = bike;
    }
    return self;
}

// 在forwardInvocation:方法中，根据选择器决定将消息转发给哪个对象
- (void)forwardInvocation:(NSInvocation *)invocation {
    SEL selector = [invocation selector];
    
    if ([_car respondsToSelector:selector]) {
        [invocation invokeWithTarget:_car];
    } else if ([_bike respondsToSelector:selector]) {
        [invocation invokeWithTarget:_bike];
    } else {
        [super forwardInvocation:invocation];
    }
}

@end

// 使用MultiVehicle对象
MultiVehicle *vehicle = [[MultiVehicle alloc] initWithCar:[Car new] andBike:[Bike new]];
[vehicle drive]; // 输出 "Driving a car"

在这个例子中，MultiVehicle类通过NSProxy实现了对Car和Bike两个类的驱动功能的代理，从而达到了类似多继承的效果。

标签：面试题,对象,使用,实现,内存,2023,Objective,方法
From： https://www.cnblogs.com/xiaomandujia/p/17927852.html