 上传我的文档
 下载
 收藏
资深进出口食品检测，熟悉各种食品检测规范，经验丰富
 下载此文档
正在努力加载中...
iOS面试题汇总
下载积分：1000
内容提示：iOS面试题汇总
文档格式：DOC|
浏览次数：15|
上传日期： 16:01:28|
文档星级：
全文阅读已结束，如果下载本文需要使用
 1000 积分
下载此文档
该用户还上传了这些文档
iOS面试题汇总
官方公共微信iOS面试题汇总(一)
是第一篇：
1.Difference between shallow copy and deep copy?
浅复制和深复制的区别？

答案：浅层复制：只复制指向对象的指针，而不复制引用对象本身。
深层复制：复制引用对象本身。
意思就是说我有个A对象，复制一份后得到A_copy对象后，对于浅复制来说，A和A_copy指向的是同一个内存资源，复制的只不过是是一个指针，对象本身资源
还是只有一份，那如果我们对A_copy执行了修改操作,那么发现A引用的对象同样被修改，这其实违背了我们复制拷贝的一个思想。深复制就好理解了,内存中存在了
两份独立对象本身。
用网上一哥们通俗的话将就是：
浅复制好比你和你的影子，你完蛋，你的影子也完蛋
深复制好比你和你的克隆人，你完蛋，你的克隆人还活着。
2.What is advantage of categories? What is difference between implementing a category and inheritance?
类别的作用？继承和类别在实现中有何区别？
答案：category 可以在不获悉，不改变原来代码的情况下往里面添加新的方法，只能添加，不能删除修改。
并且如果类别和原来类中的方法产生名称冲突，则类别将覆盖原来的方法，因为类别具有更高的优先级。
类别主要有3个作用：
(1)将类的实现分散到多个不同文件或多个不同框架中。
(2)创建对私有方法的前向引用。
(3)向对象添加非正式协议。
 继承可以增加，修改或者删除方法，并且可以增加属性。
3.Difference between categories and extensions?
类别和类扩展的区别。
答案：category和extensions的不同在于 后者可以添加属性。另外后者添加的方法是必须要实现的。
extensions可以认为是一个私有的Category。
4.Difference between protocol in objective c and interfaces in java?
obc中的协议和java中的接口概念有何不同？

答案：OBC中的代理有2层含义，官方定义为 formal和informal protocol。前者和接口一样。
informal protocol中的方法属于设计模式考虑范畴，不是必须实现的，但是如果有实现，就会改变类的属性。
其实关于正式协议，类别和非正式协议我很早前学习的时候大致看过，也写在了学习教程里
&非正式协议概念其实就是类别的另一种表达方式&这里有一些你可能希望实现的方法，你可以使用他们更好的完成工作&。
这个意思是，这些是可选的。比如我门要一个更好的方法，我们就会申明一个这样的类别去实现。然后你在后期可以直接使用这些更好的方法。
这么看，总觉得类别这玩意儿有点像协议的可选协议。&
现在来看，其实protocal已经开始对两者都统一和规范起来操作，因为资料中说&非正式协议使用interface修饰&，
现在我们看到协议中两个修饰词：&必须实现(@requied)&和&可选实现(@optional)&。
5.What are KVO and KVC?

答案：k:键 - 值编码是一种间接访问对象的属性使用字符串来标识属性，而不是通过调用存取方法，直接或通过实例变量访问的机制。
很多情况下可以简化程序代码。apple文档其实给了一个很好的例子。
kvo:键值观察机制，他提供了观察某一属性变化的方法，极大的简化了代码。
具体用看到嗯哼用到过的一个地方是对于按钮点击变化状态的的监控。
比如我自定义的一个button
[cpp] 
[self addObserver:self forKeyPath:@&highlighted& options:0 context:nil]; 
 
 
#pragma mark KVO 
 
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context 
{ 
 if ([keyPath isEqualToString:@&highlighted&] ) { 
 [self setNeedsDisplay]; 
 } 
}
对于是根据keypath去取的到相应的值发生改变，理论上来说是和kvc机制的道理是一样的。
对于kvc机制如何通过key寻找到value：
&当通过KVC调用对象时，比如：[self valueForKey:@&someKey&]时，程序会自动试图通过几种不同的方式解析这个调用。首先查找对象是否带有 someKey 这个方法，如果没找到，会继续查找对象是否带有someKey这个实例变量（iVar），如果还没有找到，程序会继续试图调用 -(id) valueForUndefinedKey:这个方法。如果这个方法还是没有被实现的话，程序会抛出一个NSUndefinedKeyException异常错误。
 
(注：Key-Value Coding查找方法的时候，不仅仅会查找someKey这个方法，还会查找getsomeKey这个方法，前面加一个get，或者_someKey以及_getsomeKey这几种形式。同时，查找实例变量的时候也会不仅仅查找someKey这个变量，也会查找_someKey这个变量是否存在。）
 
设计valueForUndefinedKey:方法的主要目的是当你使用-(id)valueForKey方法从对象中请求值时，对象能够在错误发生前，有最后的机会响应这个请求。这样做有很多好处，下面的两个例子说明了这样做的好处。&
来至cocoa，这个说法应该挺有道理。
因为我们知道button却是存在一个highlighted实例变量.因此为何上面我们只是add一个相关的keypath就行了，
可以按照kvc查找的逻辑理解，就说的过去了。
6.What is purpose of delegates?
代理的作用？
答案：代理的目的是改变或传递控制链。允许一个类在某些特定时刻通知到其他类，而不需要获取到那些类的指针。可以减少框架复杂度。
另外一点，代理可以理解为java中的回调监听机制的一种类似。
7.What are mutable and immutable types in Objective C?
obc中可修改和不可以修改类型。

答案：可修改不可修改的集合类。这个我个人简单理解就是可动态添加修改和不可动态添加修改一样。
比如NSArray和NSMutableArray。前者在初始化后的内存控件就是固定不可变的，后者可以添加等，可以动态申请新的内存空间。
8.When we call objective c is runtime language what does it mean?
我们说的obc是动态运行时语言是什么意思？

答案：多态。 主要是将数据类型的确定由编译时，推迟到了运行时。
这个问题其实浅涉及到两个概念，运行时和多态。
简单来说，运行时机制使我们直到运行时才去决定一个对象的类别，以及调用该类别对象指定方法。
多态：不同对象以自己的方式响应相同的消息的能力叫做多态。意思就是假设生物类（life）都用有一个相同的方法-
那人类属于生物，猪也属于生物，都继承了life后，实现各自的eat，但是调用是我们只需调用各自的eat方法。
也就是不同的对象以自己的方式响应了相同的消息（响应了eat这个选择器）。
因此也可以说，运行时机制是多态的基础？~~~
9.what is difference between NSNotification and protocol?
通知和协议的不同之处？

答案：协议有控制链(has-a)的关系，通知没有。
首先我一开始也不太明白，什么叫控制链（专业术语了~）。但是简单分析下通知和代理的行为模式，我们大致可以有自己的理解
简单来说，通知的话，它可以一对多，一条消息可以发送给多个消息接受者。
代理按我们的理解，到不是直接说不能一对多，比如我们知道的明星经济代理人，很多时候一个经济人负责好几个明星的事务。
只是对于不同明星间，代理的事物对象都是不一样的，一一对应，不可能说明天要处理A明星要一个发布会，代理人发出处理发布会的消息后，别称B的
发布会了。但是通知就不一样，他只关心发出通知，而不关心多少接收到感兴趣要处理。
因此控制链（has-a从英语单词大致可以看出，单一拥有和可控制的对应关系。
10.What is push notification?
什么是推送消息？

11.Polymorphism？
关于多态性

答案：多态，子类指针可以赋值给父类。
这个题目其实可以出到一切面向对象语言中，
因此关于多态，继承和封装基本最好都有个自我意识的理解，也并非一定要把书上资料上写的能背出来。
最重要的是转化成自我理解。
12.Singleton?
对于单例的理解

答案：11，12题目其实出的有点泛泛的感觉了，可能说是语言需要或是必备的基础。
基本能用熟悉的语言写出一个单例，以及可以运用到的场景或是你编程中碰到过运用的此种模式的框架类等。
进一步点，考虑下如何在多线程访问单例时的安全性。
13.What is responder chain?
说说响应链

答案： 事件响应链。包括点击事件，画面刷新事件等。在视图栈内从上至下，或者从下之上传播。
可以说点事件的分发，传递以及处理。具体可以去看下touch事件这块。因为问的太抽象化了
严重怀疑题目出到越后面就越笼统。
14.Difference between frame and bounds?
frame和bounds有什么不同？

答案:frame指的是：该view在父view坐标系统中的位置和大小。（参照点是父亲的坐标系统）
bounds指的是：该view在本身坐标系统中 的位置和大小。（参照点是本身坐标系统）
15.Difference between method and selector?
方法和选择器有何不同？

答案：selector是一个方法的名字，method是一个组合体，包含了名字和实现.
详情可以看apple文档。
16.Is there any garbage collection mechanism in Objective C.?
OBC的垃圾回收机制？

答案： OBC2.0有Garbage collection，但是iOS平台不提供。
一般我们了解的objective-c对于内存管理都是手动操作的，但是也有自动释放池。
但是差了大部分资料，貌似不要和arc机制搞混就好了。
求更多~~
17.NSOperation queue?

答案：存放NSOperation的集合类。
操作和操作队列，基本可以看成java中的线程和线程池的概念。用于处理ios多线程开发的问题。
网上部分资料提到一点是，虽然是queue，但是却并不是带有队列的概念，放入的操作并非是按照严格的先进现出。
这边又有个疑点是，对于队列来说，先进先出的概念是Afunc添加进队列，Bfunc紧跟着也进入队列，Afunc先执行这个是必然的，
但是Bfunc是等Afunc完全操作完以后，B才开始启动并且执行，因此队列的概念离乱上有点违背了多线程处理这个概念。
但是转念一想其实可以参考银行的取票和叫号系统。
因此对于A比B先排队取票但是B率先执行完操作，我们亦然可以感性认为这还是一个队列。
但是后来看到一票关于这操作队列话题的文章，其中有一句提到
&因为两个操作提交的时间间隔很近，线程池中的线程，谁先启动是不定的。&
瞬间觉得这个queue名字有点忽悠人了，还不如pool~
综合一点，我们知道他可以比较大的用处在于可以帮组多线程编程就好了。
18.What is lazy loading?

答案：懒汉模式，只在用到的时候才去初始化。
也可以理解成延时加载。
我觉得最好也最简单的一个列子就是tableView中图片的加载显示了。
一个延时载，避免内存过高，一个异步加载，避免线程堵塞。
19.Can we use two tableview controllers on one viewcontroller?
是否在一个视图控制器中嵌入两个tableview控制器？

答案：一个视图控制只提供了一个View视图，理论上一个tableViewController也不能放吧，
只能说可以嵌入一个tableview视图。当然，题目本身也有歧义，如果不是我们定性思维认为的UIViewController，
而是宏观的表示视图控制者，那我们倒是可以把其看成一个视图控制者，它可以控制多个视图控制器，比如TabbarController
那样的感觉。
20.Can we use one tableview with two different datasources? How you will achieve this?
一个tableView是否可以关联两个不同的数据源？你会怎么处理？

答案：首先我们从代码来看，数据源如何关联上的，其实是在数据源关联的代理方法里实现的。
因此我们并不关心如何去关联他，他怎么关联上，方法只是让我返回根据自己的需要去设置如相关的数据源。
因此，我觉得可以设置多个数据源啊，但是有个问题是，你这是想干嘛呢？想让列表如何显示，不同的数据源分区块显示？
21.Object－c的类可以多重继承么？可以实现多个接口么？重写一个类的方式用继承好还是分类好？为什么？
Objective-c只支持单继承，如果要实现多继承的话，可以通过类别和协议的方式来实现，cocoa 中所有的类都是NSObject 的子类，多继承在这里是用protocol 委托代理 来实现的。
22.#import 跟#include 又什么区别 ＃import&& 跟 #import&&又什么区别？
答案：@class一般用于头文件中需要声明该类的某个实例变量的时候用到，在m文 件中还是需要使用#import而#import比起#include的好处就是不会引起交叉编译。
23.类变量的@protected ,@private,@public,@package声明各有什么含义？
24.id 声明的对象有什么特性？
答案：id是个很重要的类型，是个可以指向任何类型的指针或者可以理解为指向任何未知类型的指针。
25.MVC是什么？有什么特性？为什么在iPhone上被广泛运用？
答案：MVC设计模式考虑三种对象：模型对象、视图对象、和控制器对象。模型对象代表 特别的知识和专业技能，它们负责保有应用程序的数据和定义操作数据的逻辑。视图对象知道如何显示应用程序的模型数据，而且可能允许用户对其进行编辑。控制 器对象是应用程序的视图对象和模型对象之间的协调者。
26.对于语句NSString* testObject = [[NSData alloc] init];testObject 在编译时和运行时分别是什么类型的对象？
27.什么是安全释放？
28.为什么有些4.0独有的objective－c 函数在3.1上运行时会报错.而4.0独有的类在3.1上分配内存时不会报错？分配的结果是什么？
29.为什么4.0独有的c函数在3.1的机器上运行不会报错（在没有调用的情况下？）而4.0独有的类名在3.1的机器上一运行就报错？
30.异常exception 怎么捕获？不同的CPU结构上开销怎样？C中又什么类似的方法？
31.property中属性retain,copy,assgin的含义分别是什么？有什么区别？将其转换成get／set方法怎么做？有什么注意事项？
32.委托是什么？委托的property声明用什么属性？为什么？
34.Cocoa中有虚基类的概念么？怎么简洁的实现？
35.自动释放池跟GC（垃圾回收）有什么区别？iPhone上有GC么？［pool release］ 和［pool drain］有什么区别？
iPhone上没有GC。iPhone开发的时候没有垃圾回收机制。
在垃圾回收环境中，release是一个空操作。因此，NSAutoreleasePool提供了drain方法，在引用计数环境中，该方法的作用等同于调用release，但在垃圾回收环境中，它会触发垃圾回收（如果自上次垃圾回收以来分配的内存大于当前的阈值）。因此，在通常情况下，您应该使用drain而不是release来销毁自动释放池。
for(int index = 0; index & 20; index ++){
NSString *tempStr = @&tempStr&;
NSLog(tempStr);
NSNumber *tempNumber = [NSNumber numberWithInt:2];
NSLog(tempNumber);
这段代码有什么问题.？会不会造成内存泄露（多线程）？在内存紧张的设备上做大循环时自动释放池是写在循环内好还是循环外好？为什么？
37.内存管理的几条原则时什么？按照默认法则.那些关键字生成的对象需要手动释放？在和property结合的时候怎样有效的避免内存泄露？
38.在一个对象释放前.如果他被加到了notificationCenter 中.不在notificationcenter中remove这个对象可能会出现什么问题？
39.怎样实现一个 singleton的类.给出思路。
40.什么是序列化或者Acrchiving,可以用来做什么,怎样与copy结合,原理是什么?.
41. 线程与进程的区别和联系?
答案: 进程和线程都是由操作系统所体会的程序运行的基本 单元，系统利用该基本单元实现系统对应用的并发性。
程和线程的主要差别在于它们是不同的操作系统资源 管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变 量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一 些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。
42.在iphone上有两件事情要做,请问是在一个线程里按顺序做效率高还是两个线程里做效率高？为什么？
43.runloop是什么？在主线程中的某个函数里调用了异步函数，怎么样block当前线程,且还能响应当前线程的timer事件，touch事件等.
44.ios平台怎么做数据的持久化?coredata和sqlite有无必然联系？coredata是一个关系型吗？
iOS中可以有四种持久化数据的方式： 属性列表、对象归档、SQLite3和Core Data；core data可以使你以图形界面的方式快速的定义app的数据模型，同时在你的代码中容易获取到它。core data提供了基础结构去处理常用的功能，例如保存，恢复，撤销和重做，允许你在app中继续创建新的任务。在使用core data的时候，你不用安装额外的数据库系统，因为core data使用内置的sqlite数据库。core data将你app的模型层放入到一组定义在内存中的数据对象。core data会追踪这些对象的改变，同时可以根据需要做相反的改变，例如用户执行撤销命令。当core data在对你app数据的改变进行保存的时候，core data会把这些数据归档，并永久性保存。
mac os x中sqlite库，它是一个轻量级功能强大的关系数据引擎，也很容易嵌入到应用程序。可以在多个平台使用，sqlite是一个轻量级的嵌入式编程。与core data框架不同的是，sqlite是使用程序式的，sql的主要的API来直接操作数据表。
Core Data不是一个关系型数据库，也不是关系型数据库管理系统(RDBMS)。虽然Core Dta支持SQLite作为一种存储类型，但它不能使用任意的SQLite数据库。Core Data在使用的过程种自己创建这个数据库。Core Data支持对一、对多的关系。
45.阐述一个nil对象从interface bulider产生，到载入程序运行空间，最后被释放时所经历的生命周期.1475人阅读
描述一下MVC
MVC是一种架构模式，使用此架构模式的好处在于：业务逻辑、数据、视图的分离。做到高内聚低耦合
摘自《Cocoa Design Patterns》:
MVC的主要目的是解除模型子系统和视图之间的耦合，这样它们就可以独立变化。
摘自《设计模式》:
MVC通过建立一个”订购/通知”协议来分离视图和模型。视图必须保证它的显示正确地反映了模型的状态。一旦模型的数据发生变化，模型将通知有关的视图，每个模型的数据发生变化，模型将通知有关的视图，每个视图相应地得到刷新自己的机会。这种方法可以让你为一个模型提供不同的多个视图表现形式，也能够为一个模型创建新的视图而无须重写模型。
参考唐巧的技术博客-
M-Model-模型
V-View-视图
C-Controller-控制器
Controller与Model之间，Controller一侧是虚线，代表Controller可以直接访问Model；Model一侧是白色实线，代表不能直接访问Controller，但模型发生改变，Controller想要知道，这个时候可以采用观察者模式，间接地去通知Controller
Controller与View之间，Controller一侧是虚线，代表Controller可以直接访问View(如果有Storyboard，需要通过Outlet访问)；View一侧是白色实线，代表不能直接访问Controller。如果View接收到用户交互时，可以通过目标选择器(Target、Selector/Action)进行回调Controller；如果View需要向Controller获取数据(cell个数、给你一个indexPath，你给我一个我要显示的Cell、TextField的文字发生变化，TextField接收到了一个”Return”按键)时，通过Delegate或DataSource向Controller回调，注：此图当中少了一个block！
View与Model之间，是一条黄色双实线，代表两者之间互相禁止访问或间接回调
典型案例：
Controller向Model当中取数据，显示到View(它的子类也可以，例如UIButton)上，button添加一个目标选择器，当button按下时，向Controller进行回调，Controller再去更新Model，当Model发生变化时，Controller会收到观察者消息或通知消息，再去更新View显示样式
延伸面试题:什么是高内聚低耦合？
延伸面试题:iOS中常用的设计模式？
延伸面试题:如果简历当中或自我介绍当中，或谈话过程当中，出现MVVM，会提问两者的区别。有些面试者会回答MVC架构模式当中的Controller层，会显得越来越臃肿，而MVVM则不会。此种回答会扣分，因为MVC架构模式只有当模块的职责划分不明确，才会造成Controller的臃肿，也就意味着：面试者的技术能力不足。所以MVVM这一概念一定要真的用过才能回答！
陷阱：MVC是一种架构模式，注意不是设计模式
陷阱：Notification和KVO有什么区别？在什么情况下使用Notification，在什么情况下使用KVO？
iOS如何使用多线程
回答思路：
NSOperation
NSOperationQueue
NSInvocationOperation
NSBlockOperation
dispatch_async
dispatch_sync
dispatch_group
dispatch_semaphore
dispatch_after
dispatch_once
dispatch_barrier
dispatch_source
延伸面试题：NSOperation与GCD的区别
NSOperation与GCD的区别
使用起来较为简单
GCD任务只要被启动，理论上是不能够被停止的
GCD因为是使用block编写的，如果线程的控制情况比较复杂，block嵌套就会变多，所以这种情况下代码可读性就会变差
NSOperation
可以像NSThread一样，发送cancel方法。内部根据当前线程的cancel状态做相应的处理
可以根据NSOperationQueue的最大变发量，来控制线程的并发(异步)或串行(同步)
相比GCD，代码可读性较好
因为NSOperation需要依赖于NSOperationQueue(任务队列)，此任务队列对象需要额外的代码进行管理、分配、释放
延伸面试题：NSOperation被发送了cancel方法，会立即地停止吗？
延伸面试题：如果不会立即停止，那还有什么意义呢？
NSOperation被发送了cancel方法，会立即停止吗？如果会，那还有什么意义？
不会立即停止，只是向NSOperation对象发送了一个”我要取消你”的消息。NSOperation内部需要在合适的时机，判断自己是否接收到”取消”这种消息，做一些扫尾的操作，再自己把自己停止掉。
这种机制类似于用户双击了Home键，将App划出了屏幕，杀掉了这个App，但是App还是会在被杀掉之前接收到-(void)applicationWillTerminate消息，做数据的保存工作
C语言中auto，register，static，const，volatile的区别
参考zhige博客
iOS中常用的设计模式
观察者模式
适配器模式(即delegate)
原型模式(即copy)
命令模式(即target-selector)
延伸面试题1：工厂模式与单例模式的区别
延伸面试题2：观察者模式与适配器模式的区别
延伸面试题3：KVC和KVO之间的联系
延伸面试题4：KVO和NSNotificationCenter的区别
延伸面试题5：单例模式怎样实现
陷阱：一些面试者会回答MVC、KVO、KVC、Notification，注意MVC是架构模式，KVO和Notification是观察者模式在iOS当中的实现方式，KVC是键值观察编码，也不是设计模式。另，设计模式是在所有的程序语言全部适用的，既然全部适用，KVO也会在Java当中可以使用吗？
单例模式怎么实现
+ (instancetype)sharedInstance {
static id sharedClient =
static dispatch_once_t onceT
dispatch_once(&onceToken, ^{
sharedClient = [[self alloc] init];
return sharedC
+ (instancetype)sharedInstance {
static id sharedClient =
@synchronized (self) {
sharedClient = [[self alloc] init];
return sharedC
+ (instancetype)sharedInstance {
static id sharedClient =
if (sharedClient == nil) {
sharedClient = [[self alloc] init];
return sharedC
什么是高内聚低耦合
内聚就是一个模块内各个元素彼此结合的紧密程度，高内聚就是一个模块内各个元素彼此结合的紧密程度高。
所谓高内聚是指一个软件模块是由相关性很强的代码组成，只负责一项任务，也就是常说的单一责任原则。
耦合：一个软件结构内不同模块之间互连程度的度量(耦合性也叫块间联系。指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密，其耦合性就越强，模块的独立性则越差，模块间耦合的高低取决于模块间接口的复杂性，调用的方式以及传递的信息。)
对于低耦合，粗浅的理解是：一个完整的系统，模块与模块之间，尽可能的使其独立存在。也就是说，让每个模块，尽可能的独立完成某个特定的子功能。模块与模块之间的接口，尽量的少而简单。如果某两个模块间的关系比较复杂的话，最好首先考虑进一步的模块划分。这样有利于修改和组合。
说得比较文绉绉的，我们来接点地气
比如一个ViewController，它又要负责UITableView的delegate、dataSource，又要负责UITextField的delegate，又要负责网络请求，又要负责网络的响应及Model的更新….这种设计，就是内聚性较差的体现。高内聚这个概念，与”面向对象设计的五大原则”（SOLID）当中的单一职责原则（SRP）意义相近，即”一个类，只干一件事”
耦合又是什么？即是模块与模块之间的依赖。举之前的例子，在ViewController当中，又要依赖View，又要依赖AFNetworking，又要依赖Model…这种设计，就是耦合性较高的体现。低耦合这个概念，与”面向对象设计的五大原则”(SOLID)当中的依赖倒置原则(DIP)与接口隔离原则(SIP)意义相近。
NSNotificationCenter和KVO有什么区别？
两者的共同点：都是观察者模式
两者的不同点：KVO是键值观察，NSNotificationCenter是通知中心。在适用场景上，KVO必须有一个键，它才能观察值的变化。而NSNotificationCenter不需要
如果要观察的内容是跟模型相关的，使用KVO。反之，则使用NSNotificationCenter
陷阱：一些面试者会回答Notification是一对一，KVO是多对多
什么是线程？什么是进程？二者有什么区别和联系？
进程是一个“执行中的程序”，在iOS编程中，是不支持多进程设计的。比如在Mac系统下，登录了一个QQ号，再按下快捷键Command+N，又可以再登录一个QQ号，这时，QQ这个应用程序就开启了两个进程。但在iOS当中不能够双开。
在一个进程当中，可以有多个线程，但至少有一个主线程在一直运行，它们可以利用所在进程所拥有的资源。比如多个线程都可以去操作Model…
多进程设计中，一个进程crash，不会影响其他的进程。
多线程设计中，一个线程crash，会影响其他的线程。
如果进程crash了，它的所有线程也会crash。
延伸面试题：在iOS当中怎样设计线程？
延伸面试题：线程同步问题
iOS持久化存储都有哪几种方式？
NSUserDefault
归档/解归档
MagicalRecord
延伸面试题：SQLite与CoreData的区别？
延伸面试题：CoreData与MagicalRecord的区别？
延伸面试题：如果在简历当中或项目描述当中体现了FMDB或SQLite，可能会问到多表查询的SQL语句。
延伸面试题：CoreData如何做表结构升级？
延伸面试题：CoreData使用的过程当中，有没有遇到过死锁，如何解决？
延伸面试题：使用数据库有何心得？
陷阱：如果涉及到多表查询的SQL，恰巧面试者不知道。会给面试官留下之前项目太简单的印象，进而对面试者的技术能力产生怀疑
SQLite与CoreData的区别？
CoreData即是对SQLite的封装，在CoreData当中，操作数据库的代码即是操作对象的代码
CoreData与MagicalRecord的区别
MagicalRecord是对CoreData的封装，使用起来比CoreData更简单。并且其内部考虑到了多线程操作数据库产生死锁的问题
使用数据库有何心得？有没有遇到过死锁？如何解决？
操作数据库不要过于频繁，一般情况下在程序启动时，将数据库当中的所有数据，读入到Model当中；程序关闭时，将Model当中的所有数据，存储到数据库当中。并且引入MagicalRecord
多线程同步和异步的区别？iOS中如何实现多线程同步？
多线程同步，即是排队效果，类似于交通路口的信号灯，后边的车要直行，但是前面的车在等待左转信号灯，后面的灯要等到前面的车走了之后才能继续走。不然的话就会继续等待
多线程异步，即是”并发执行”。多用于会造成阻塞的任务，如：网络请求如果使用同步，主线程会卡死，页面不再刷新，不再响应用户交互…如果使用异步，主线程继续处理页面刷新，响应用户交互，而另外一个线程则等待网络响应
多线程同步可采用以下方式：
dispatch_semaphore
原子操作OSAtomic
事件NSCondition
延伸面试题：属性关键字当中的nonatomic与atomic有什么区别？
堆和栈的区别
堆和栈的概念请自行百度，一般情况下不会出现错误。在此仅说明它们之间的区别。
例如以下代码：
- (void)method {
NSObject *obj1 = [[NSObject alloc] init];
NSObject *obj2 = [[NSObject alloc] init];
NSInteger inta = 0;
NSInteger intb = 0;
堆区内容：
按照内存管理的法则，有alloc，就必须要有release。但此段代码没有做release并不是真的不需要release，而是ARC在函数结尾自动去release了。其中obj1和obj2两个对象被存放到了堆区，堆区的内容需要程序员自己手动去分配(alloc)和释放(release)
栈区内容：
由编译器自动分配释放，inta和intb两个整型数值肯定是要有一个内存区域去存储的，这一块内存不需要程序员去分配，也不需要程序员去释放
iOS有多重继承吗？没有的话用什么代替？
没有多重继承，OC只能够单继承。如果想要做多重继承的话，可以使用协议(protocol)代替
延伸面试题：因为涉及到多重继承，所以如果简历里如果体现出其他的编程语言，可能会问到(很多面试者会在简历里提到C++、Java，这时面试极有可能问到多重继承、虚函数、纯虚函数、抽象类之类的概念)
动态绑定、运行时、编译时
如有下列代码：
NSString *str = [[NSData alloc] init];
str = [str stringByAppendingString:@"abc"]
会不会顺利通过编译？如果编译通过，运行过程当中会发生什么？
答：会顺利通过编译，但编译器会报警告。在编译时，str是NSString类型，但在运行时，会创建一个NSData对象，并将str动态绑定成NSData，既然str实际上是一个NSData对象，而NSData对象又没有实现”stringByAppeningString”方法，所以会发生闪退。
#import、#include和@class有什么区别？@class代表着什么？如果没有#import关键字，你会怎么做？
#import和#include都是导入头文件，但#import在编译时能够保证”只导入一次”，但#include做不到。所以如果没有#import关键字，只能使用#include关键字，可以在被导入的头文件当中添加如下代码：
#ifndef _HEADER_H // 此处的_HEADER_H应该根据实际的头文件名取得
#define _HEADER_H
// 实际内容
@class 是为了防止交叉编译，一般优秀的设计，会尽量避免两个头文件相互导入，但有时确实避免不了，两个头文件相互导入，编译器就会报错。比如：
Teacher.h:
#import "Student.h"
@interface Teacher : NSObject
@property (strong, nonatomic) NSMutableArray&Student *& *
Student.h:
#import "Teacher.h"
@interface Student : NSobject
@property (strong, nonatomic) NSMutableArray&Teacher *& *
此时@class关键字就可以派上用场了，将头文件当中的#import剪切替换到.m文件当中，并在头文件当中的相同位置，添加@class关键字就可解决
property关键字中,assign, weak, retain, strong, copy, atomic, nonatomic, readonly, readwrite分别是什么意思？
如果是C语言基础类型，使用assign(CGFloat, long, int, short, NSInteger, NSUInteger)
如果是代理，使用weak(MRC使用assign)
如果强引用了，需要将一个strong改成
如果对象需要保存一份副本，不想别人的修改了，自己也跟着修改，那么使用copy
剩下的，都使用strong(MRC当中使用retain)
原子操作：线程安全，相当于在getter和settger两个函数当中，添加了线程锁
非原子操作-非线程安全
原子操作-线程安全
self.imageView.money =
strong、retain
strong是在ARC当中用的，retain是在MRC当中用的
引用计数自动+1
- (void)setImage:(UIImage *)image {
if (_image != image) {
[image retain];
[_image release];
- (void)dealloc {
[_image release];
- (void)setUnknown:(Unknown )var {
大体上跟assign一样，不一样的:如果在指向的对象被销毁了，那么指针会指向nil
- (void)setString:(NSString *)string {
if (_string != string) {
[_string release]
_string = [string copy];
在别的类使用的过程当中，不能够调用setter方法
在自己的类中，如果要使用，可以在.m文件当中，自己再写一个匿名类别，写上与.h文中相同的property内容(删掉readonly关键字)，就可以使用了
属性二次定义
问：对于其他的类，属性是只读的，但对于自己的类，是可读可写的，如何做？
答：直接上代码
Template.h:
@inteface Template : NSObject
@property (strong, nonatomic, readonly) NSObject *
Template.m:
@interface Template()
@property (strong, nonatomic) NSObject *
@implementation Template
iOS捕捉屏幕
+[UIImage imageFromView:]
事件响应者链的概念
响应者链表示一系列的响应者对象。事件被交由第一响应者对象处理，如果第一响应者不处理，事件被沿着响应者链向上传递，交给下一个响应者(next responder)。一般来说，第一响应者是个视力对象或者其子类对象，当其被触摸后事件被交由它处理，如果它不处理，事件就会被传递给它的视力控制器对象(如果存在)，然后是它的父视图(superview)对象(如果存在)，以此类推，走到顶层视图。接下来会沿着顶层视图(top view)到窗口(UIWindow对象)再到程序(UIApplication对象)。如果整个过程都没有响应这个事件，该事件就被丢弃。一般情况下，在响应者链中只要由对象处理事件，事件就停止传递。但有时候可以在视图的响应方法中根据一些条件判断来判断是否需要继续传递事件。
const与指针
const int *cnp = 0;
int const *ncp = 0;
const * int cpn = 0;
int * const npc = 0;
int const * const ncpc = 0;
const int * const cnpc = 0;
以上6行分别是什么意思？
类别和类扩展有什么区别？
类扩展(Extension)是匿名的类别(Category)，即括号当中没有任何字符
类别和继承有什么区别？
继承是以子类化的方式，对原有类进行扩展
类别是在原有类之上，对其进行扩展
如果想要让所有的UIView及其子类都支持一个方法。比如UIButton、UILabel、UIImagView都支持一个方法-(void)customMethod，应该使用类别还是继承？
类别可以扩展属性吗？
理论上不可以，但实际上可以通过runtime方法添加。属性即是一个settger方法和一个getter方法。所以在头文件当中，直接添加属性声明就可以：
ExtensionObject.h:
#import &Foundation/Foundation.h&
@interface NSObject(ExtensionObject)
@property (retain, nonatomic) NSObject *extensionP
但是在setter和getter方法中，必须要与一个成员变量相关联，因为类别不能够添加成员变量。所以只能曲线救国了：
ExtensionObject.m:
#import "ExtensionObject.h"
#import &objc/runtime.h&
static const void *extensionPropKey = &extensionPropK
@implementation NSObject(CustomAnimate)
- (NSObject *)extensionProp {
return objc_getAssociatedObject(self, extensionPropKey);
- (void)setExtensionProp:(NSObject *)extensionProp{
objc_setAssociatedObject(self, extensionPropKey, extensionProp, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
写出一个ARC版本的工厂方法，和与之对应的MRC版本的工厂方法
// ARC版本
+ (instancetype)factory {
id factory = [[self alloc] init];
// MRC版本
+ (instancetype)factory {
id factory = [[self alloc] init];
return [factory autorelease];
内存管理基本原则，关于内存管理，有什么自己的看法或心得？
基本原则：谁使用(alloc, retain, copy)，谁释放(release、autorelease)。
心得：一律使用self.prop_name方式，不使用成员变量方式。可以避免掉绝大多数内存泄露问题。
深复制与浅复制的区别。要想获得一个对象的复制版本，代码需要怎么实现？
浅复制： 只复制对象本身，不对里面的属性复制。
深复制：不仅复制对象本身，对象持有的属性对象与做复制。
被复制的类，需要实现NSCopying协议
有如下两个类，分别写下深复制版本与浅复制版本
深复制版本
Student.h:
#import &Foundation/Foundation.h&
@interface Student : NSObject&NSCopying&
@property (strong, nonatomic) Score *
Student.m:
#import "Student.h"
#import "Score.h"
@implementation Student
- (id)copyWithZone:(NSZone *)zone {
Student *result = [[Student allocWithZone:zone] init];
result.score = [self.score copy]; // 属性也要复制
#import &Foundation/Foundation.h&
@interface Score : NSObject&NSCopying&
@property (copy, nonatomic) NSString *subjectN
@property (assign, nonatomic) NSI
#import "Score.h"
@implementation Score
- (id)copyWithZone:(NSZone *)zone {
Score *result = [[Score allocWithZone:zone] init];
result.subjectName = [self.subjectName copy];
result.score = self.
浅复制版本
Student.h:
#import &Foundation/Foundation.h&
@interface Student : NSObject&NSCopying&
@property (strong, nonatomic) Score *
Student.m:
#import "Student.h"
#import "Score.h"
@implementation Student
- (id)copyWithZone:(NSZone *)zone {
Student *result = [[Student allocWithZone:zone] init];
result.score = self. // 此处不同
#import &Foundation/Foundation.h&
@interface Score : NSObject
@property (copy, nonatomic) NSString *subjectN
@property (assign, nonatomic) NSI
#import "Score.h"
@implementation Score
ARC是否会存在内存泄露
会有内存泄露的，
1 如果不使用property自动生成的settger和getter方法，而使用成员变量。一样会出现内存泄露问题
2 如果涉及到对象复用(UITableViewCell或UICollectionViewCell)，添加了观察者，就可能同时观察多个被观察者。当Model刷新时会错乱
描述复用机制
什么是自动释放池？
@synthesize与@dynamic的区别
什么是动态绑定？
延伸面试题：C++中想要做动态绑定，怎么做？
block与协议有什么区别？你比较喜欢用哪一种
在使用block时有什么注意事项？
阅读以下代码，说明区别
@interface Template()
@property (strong, nonatomic) NSObject *
@implementation Template
- (void)method {
// 解释一下两行的区别
self.prop = [[NSObject alloc] init];
_prop = [[NSObject alloc] init];
self.prop ＝ [[NSObject alloc] init];会调用编译器自动生成的setter方法，其内部会考虑到引用计数；
而_prop = [[NSObject alloc] init];不会调用编译器自动 生成的setter方法，不会考虑到引用计数，所以有可能会产生内存泄露
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：60908次
排名：千里之外
原创：37篇
评论：16条
(1)(1)(1)(2)(3)(3)(1)(1)(2)(1)(1)(1)(1)(2)(1)(2)(2)(1)(1)(2)(2)(1)(1)(1)(4)(3)
(window.slotbydup = window.slotbydup || []).push({
id: '4740887',
container: s,
size: '250,250',
display: 'inlay-fix'}