iOS开发－面试总结（九）

时间 2019-11-08

标签 ios 开发面试总结栏目 iOS 繁體版

原文原文链接

iOS面试指导java

一ios

通过本人最近的面试和对面试资料的一些汇总，准备记录这些面试题，以便ios开发工程师找工做复习之用，本人但愿有面试经验的同窗能和我同时完成这个模块，先出面试题，而后会放出答案。c++

1. 你使用过Objective-C的运行时编程（Runtime Programming）么？若是使用过，你用它作了什么？你还能记得你所使用的相关的头文件或者某些方法的名称吗？
答案：Objecitve-C的重要特性是Runtime（运行时）,在#import <objc/runtime.h> 下能看到相关的方法，用过objc_getClass()和class_copyMethodList()获取过私有API;使用
objective-c
Method method1 = class_getInstanceMethod(cls, sel1);
Method method2 = class_getInstanceMethod(cls, sel2);
method_exchangeImplementations(method1, method2);
代码交换两个方法，在写unit test时使用到。git

2. 你实现过多线程的Core Data么？NSPersistentStoreCoordinator，NSManagedObjectContext和NSManagedObject中的哪些须要在线程中建立或者传递？你是用什么样的策略来实现的？
答案：没实现过多线程的CoreData(待实践)程序员

3. Core开头的系列的内容。是否使用过CoreAnimation和CoreGraphics。UI框架和CA，CG框架的联系是什么？分别用CA和CG作过些什么动画或者图像上的内容。（有须要的话还能够涉及Quartz的一些内容）
答案：UI框架的底层有CoreAnimation，CoreAnimation的底层有CoreGraphics。
UIKit |
———— |
Core Animation |
Core Graphics |
Graphics Hardware|
使用CA作过menu菜单的展开收起（太逊了）github

4. 是否使用过CoreText或者CoreImage等？若是使用过，请谈谈你使用CoreText或者CoreImage的体验。
答案：CoreText能够解决复杂文字内容排版问题。CoreImage能够处理图片，为其添加各类效果。体验是很强大，挺复杂的。web

5. NSNotification和KVO的区别和用法是什么？何时应该使用通知，何时应该使用KVO，它们的实现上有什么区别吗？若是用 protocol和delegate（或者delegate的Array）来实现相似的功能可能吗？若是可能，会有什么潜在的问题？若是不能，为何？（虽然protocol和delegate这种东西面试已经面烂了…）
答案：NSNotification是通知模式在iOS的实现，KVO的全称是键值观察(Key-value observing),其是基于KVC（key-value coding）的，KVC是一个经过属性名访问属性变量的机制。例如将Module层的变化，通知到多个Controller对象时，能够使用 NSNotification；若是是只须要观察某个对象的某个属性，能够使用KVO。
对于委托模式，在设计模式中是对象适配器模式，其是delegate是指向某个对象的，这是一对一的关系，而在通知模式中，每每是一对多的关系。委托模式，从技术上能够如今改变delegate指向的对象，但不建议这样作，会让人迷惑，若是一个delegate对象不断改变，指向不一样的对象。面试

6. 你用过NSOperationQueue么？若是用过或者了解的话，你为何要使用NSOperationQueue，实现了什么？请描述它和GCD的区别和相似的地方（提示：能够从二者的实现机制和适用范围来描述）。
答案：使用NSOperationQueue用来管理子类化的NSOperation对象，控制其线程并发数目。GCD和NSOperation均可以实现对线程的管理，区别是 NSOperation和NSOperationQueue是多线程的面向对象抽象。项目中使用NSOperation的优势是NSOperation是对线程的高度抽象，在项目中使用它，会使项目的程序结构更好，子类化 NSOperation的设计思路，是具备面向对象的优势（复用、封装），使得实现是多线程支持，而接口简单，建议在复杂项目中使用。
项目中使用GCD的优势是GCD自己很是简单、易用，对于不复杂的多线程操做，会节省代码量，而Block参数的使用，会是代码更为易读，建议在简单项目中使用。
更详细的答案见个人这篇文章objective-c

7. 既然提到GCD，那么问一下在使用GCD以及block时要注意些什么？它们两是一回事儿么？block在ARC中和传统的MRC中的行为和用法有没有什么区别，须要注意些什么？如何避免循环引用？
答案：使用block是要注意，若将block作函数参数时，须要把它放到最后，GCD是Grand Central Dispatch，是一个对线程开源类库，而Block是闭包，是可以读取其余函数内部变量的函数。更详细的答案见个人这篇文章算法

8. 您是否作过异步的网络处理和通信方面的工做？若是有，能具体介绍一些实现策略么？
答案：使用NSOperation发送异步网络请求，使用NSOperationQueue管理线程数目及优先级，底层是用NSURLConnetion，详细可见开源框架[LWConnetion](https://github.com/xunyn/LWConnetionDemo)。

9. 对于Objective-C，你认为它最大的优势和最大的不足是什么？对于不足之处，如今有没有可用的方法绕过这些不足来实现需求。若是能够的话，你有没有考虑或者实践太重新实现OC的一些功能，若是有，具体会如何作？
答案：最大的优势是它的运行时特性，不足是没有命名空间，对于命名冲突，能够使用长命名法或特殊前缀解决，若是是引入的第三方库之间的命名冲突，能够使用link命令及flag解决冲突。

10. 你实现过一个框架或者库以供别人使用么？若是有，请谈一谈构建框架或者库时候的经验；若是没有，请设想和设计框架的public的API，并指出大概须要如何作、须要注意一些什么方面，来使别人容易地使用你的框架。
答案：抽象和封装，方便使用。首先是对问题有充分的了解，好比构建一个文件解压压缩框架，从使用者的角度出发，只需关注发送给框架一个解压请求，框架完成复杂文件的解压操做，而且在适当的时候通知给是哦难过者，如解压完成、解压出错等。在框架内部去构建对象的关系，经过抽象让其更为健壮、便于更改。其次是 API的说明文档。

11.写一个NSString类的实现
答案：+ (id)initWithCString:(c*****t char *)nullTerminatedCString encoding:(NSStringEncoding)encoding;
+ (id) stringWithCString: (c*****t char*)nullTerminatedCString
encoding: (NSStringEncoding)encoding
{
NSString *obj;
obj = [self allocWithZone: NSDefaultMallocZone()];
obj = [obj initWithCString: nullTerminatedCString encoding: encoding];
return AUTORELEASE(obj);
}

12.static 关键字的做用：
答案：（1）函数体内 static 变量的做用范围为该函数体，不一样于 auto 变量，该变量的内存只被分配一次，
所以其值在下次调用时仍维持上次的值；
（2）在模块内的 static 全局变量能够被模块内所用函数访问，但不能被模块外其它函数访问；
（3）在模块内的 static 函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明
它的模块内；
（4）在类中的 static 成员变量属于整个类所拥有，对类的全部对象只有一份拷贝；
（5）在类中的 static 成员函数属于整个类所拥有，这个函数不接收 this 指针，于是只能访问类的static 成员变量。

13.线程与进程的区别和联系?
答案：进程和线程都是由操做系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。
程和线程的主要差异在于它们是不一样的操做系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不一样执行路径。线程有本身的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，因此多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行而且又要共享某些变量的并发操做，只能用线程，不能用进程。

14.堆和栈的区别？
答案：管理方式：对于栈来说，是由编译器自动管理，无需咱们手工控制；对于堆来讲，释放工做由程序员控制，容易产生memory leak。
申请大小：
栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就肯定的常数），若是申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈得到的空间较小。
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是因为系统是用链表来存储的空闲内存地址的，天然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。因而可知，堆得到的空间比较灵活，也比较大。
碎片问题：对于堆来说，频繁的new/delete势必会形成内存空间的不连续，从而形成大量的碎片，使程序效率下降。对于栈来说，则不会存在这个问题，由于栈是先进后出的队列，他们是如此的一一对应，以致于永远都不可能有一个内存块从栈中间弹出
分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，好比局部变量的分配。动态分配由alloca函数进行分配，可是栈的动态分配和堆是不一样的，他的动态分配是由编译器进行释放，无需咱们手工实现。
分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的。

15.什么是键-值,键路径是什么？
答案：模型的性质是经过一个简单的键（一般是个字符串）来指定的。视图和控制器经过键来查找相应的属性值。在一个给定的实体中，同一个属性的全部值具备相同的数据类型。键-值编码技术用于进行这样的查找—它是一种间接访问对象属性的机制。
键路径是一个由用点做分隔符的键组成的字符串，用于指定一个链接在一块儿的对象性质序列。第一个键的
性质是由先前的性质决定的，接下来每一个键的值也是相对于其前面的性质。键路径使您能够以独立于模型
实现的方式指定相关对象的性质。经过键路径，您能够指定对象图中的一个任意深度的路径，使其指向相
关对象的特定属性。

16.目标-动做机制
答案：目标是动做消息的接收者。一个控件，或者更为常见的是它的单元，以插座变量（参见”插座变量”部分）
的形式保有其动做消息的目标。
动做是控件发送给目标的消息，或者从目标的角度看，它是目标为了响应动做而实现的方法。
程序须要某些机制来进行事件和指令的翻译。这个机制就是目标-动做机制。

17.objc的内存管理
答案：若是您经过分配和初始化（好比[[MyClass alloc] init]）的方式来建立对象，您就拥
有这个对象，须要负责该对象的释放。这个规则在使用NSObject的便利方法new 时也一样适用。
若是您拷贝一个对象，您也拥有拷贝获得的对象，须要负责该对象的释放。
若是您保持一个对象，您就部分拥有这个对象，须要在再也不使用时释放该对象。
反过来，
若是您从其它对象那里接收到一个对象，则您不拥有该对象，也不该该释放它（这个规则有少数的例外，在参考文档中有显式的说明）。

18.自动释放池是什么,如何工做？
答案：当您向一个对象发送一个autorelease消息时，Cocoa就会将该对象的一个引用放入到最新的自动释放池。它仍然是个正当的对象，所以自动释放池定义的做用域内的其它对象能够向它发送消息。当程序执行到做用域结束的位置时，自动释放池就会被释放，池中的全部对象也就被释放。
1）ojc-c 是经过一种”referring counting”(引用计数)的方式来管理内存的, 对象在开始分配内存(alloc)的时候引用计数为一,之后每当碰到有copy,retain的时候引用计数都会加一, 每当碰到release和autorelease的时候引用计数就会减一,若是此对象的计数变为了0, 就会被系统销毁.
2）NSAutoreleasePool 就是用来作引用计数的管理工做的,这个东西通常不用你管的.
3）autorelease和release没什么区别,只是引用计数减一的时机不一样而已,autorelease会在对象的使用真正结束的时候才作引用计数减一.

19.类工厂方法是什么
答案：类工厂方法的实现是为了向客户提供方便，它们将分配和初始化合在一个步骤中，返回被建立的对象，并
进行自动释放处理。这些方法的形式是+ (type)className…（其中 className不包括任何前缀）。
工厂方法可能不只仅为了方便使用。它们不但能够将分配和初始化合在一块儿，还能够为初始化过程提供对
象的分配信息。
类工厂方法的另外一个目的是使类（好比NSWorkspace）提供单件实例。虽然init…方法能够确认一
个类在每次程序运行过程只存在一个实例，但它须要首先分配一个“生的”实例，而后还必须释放该实例。
工厂方法则能够避免为可能没有用的对象盲目分配内存。

20.单件实例是什么
答案：Foundation 和 Application Kit 框架中的一些类只容许建立单件对象，即这些类在当前进程中的惟一实例。举例来讲，NSFileManager 和NSWorkspace 类在使用时都是基于进程进行单件对象的实例化。当向这些类请求实例的时候，它们会向您传递单一实例的一个引用，若是该实例还不存在，则首先进行实例的分配和初始化。单件对象充当控制中心的角色，负责指引或协调类的各类服务。若是类在概念上只有一个实例（好比
NSWorkspace），就应该产生一个单件实例，而不是多个实例；若是未来某一天可能有多个实例，您可
以使用单件实例机制，而不是工厂方法或函数。

21.动态绑定在运行时肯定要调用的方法
答案：动态绑定将调用方法的肯定也推迟到运行时。在编译时，方法的调用并不和代码绑定在一块儿，只有在消实发送出来以后，才肯定被调用的代码。经过动态类型和动态绑定技术，您的代码每次执行均可以获得不一样的结果。运行时因子负责肯定消息的接收者和被调用的方法。运行时的消息分发机制为动态绑定提供支持。当您向一个动态类型肯定了的对象发送消息时，运行环境系统会经过接收者的isa指针定位对象的类，并以此为起点肯定被调用的方法，方法和消息是动态绑定的。并且，您不必在Objective-C 代码中作任何工做，就能够自动获取动态绑定的好处。您在每次发送消息时，特别是当消息的接收者是动态类型已经肯定的对象时，动态绑定就会例行而透明地发生。

22.obj-c的优缺点
答案：objc优势：
1) Cateogies
2) Posing
3) 动态识别
4) 指标计算
5）弹性讯息传递
6) 不是一个过分复杂的 C 衍生语言
7) Objective-C 与 C++ 可混合编程
缺点:
1) 不支援命名空间
2) 不支持运算符重载
3）不支持多重继承
4）使用动态运行时类型，全部的方法都是函数调用，因此不少编译时优化方法都用不到。（如内联函数等），性能低劣。

23.sprintf,strcpy,memcpy使用上有什么要注意的地方
答案：strcpy是一个字符串拷贝的函数，它的函数原型为strcpy(char *dst, c*****t char *src);
将 src开始的一段字符串拷贝到dst开始的内存中去，结束的标志符号为’\0’，因为拷贝的长度不是由咱们本身控制的，因此这个字符串拷贝很容易出错。具备字符串拷贝功能的函数有memcpy，这是一个内存拷贝函数，它的函数原型为memcpy(char *dst, c*****t char* src, unsigned int len);
将长度为len的一段内存，从src拷贝到dst中去，这个函数的长度可控。可是会有内存叠加的问题。
sprintf是格式化函数。将一段数据经过特定的格式，格式化到一个字符串缓冲区中去。sprintf格式化的函数的长度不可控，有可能格式化后的字符串会超出缓冲区的大小，形成溢出。

24.readwrite，readonly，assign，retain，copy，nonatomic属性的做用
答案：@property是一个属性访问声明，扩号内支持如下几个属性：
1，getter=getterName，setter=setterName，设置setter与getter的方法名
2，readwrite,readonly，设置可供访问级别
2，assign，setter方法直接赋值，不进行任何retain操做，为了解决原类型与环循引用问题
3，retain，setter方法对参数进行release旧值再retain新值，全部实现都是这个顺序(CC上有相关资料)
4，copy，setter方法进行Copy操做，与retain处理流程同样，先旧值release，再Copy出新的对象，retainCount为1。这是为了减小对上下文的依赖而引入的机制。
copy是在你不但愿a和b共享一块内存时会使用到。a和b各自有本身的内存。
5，nonatomic，非原子性访问，不加同步，多线程并发访问会提升性能。注意，若是不加此属性，则默认是两个访问方法都为原子型事务访问。锁被加到所属对象实例级(我是这么理解的…)。
atomic和nonatomic用来决定编译器生成的getter和setter是否为原子操做。在多线程环境下，原子操做是必要的，不然有可能引发错误的结果。加了atomic，setter函数会变成下面这样：

26何时用delegate，何时用Notification？
答案：delegate针对one-to-one关系，而且reciever能够返回值给sender，notification 能够针对one-to-one/many/none,reciever没法返回值给sender.因此，delegate用于sender但愿接受到 reciever的某个功能反馈值，notification用于通知多个object某个事件。

27什么是KVC和KVO？
答：KVC(Key-Value-Coding)内部的实现：一个对象在调用setValue的时候，（1）首先根据方法名找到运行方法的时候所须要的环境参数。（2）他会从本身isa指针结合环境参数，找到具体的方法实现的接口。（3）再直接查找得来的具体的方法实现。KVO（Key-Value- Observing）：当观察者为一个对象的属性进行了注册，被观察对象的isa指针被修改的时候，isa指针就会指向一个中间类，而不是真实的类。因此 isa指针其实不须要指向实例对象真实的类。因此咱们的程序最好不要依赖于isa指针。在调用类的方法的时候，最好要明确对象实例的类名

28 ViewController 的 loadView, viewDidLoad, viewDidUnload 分别是在何时调用的？
答案：在自定义ViewController的时候这几个函数里面应该作什么工做？答：viewDidLoad在view 从nib文件初始化时调用，loadView在controller的view为nil时调用。此方法在编程实现view时调用,view 控制器默认会注册memory warning notification,当view controller的任何view 没有用的时候，viewDidUnload会被调用，在这里实现将retain的view release,若是是retain的IBOutlet view 属性则不要在这里release,IBOutlet会负责release 。

29.”NSMutableString *”这个数据类型则是表明”NSMutableString”对象自己，这二者是有区别的。而NSString只是对象的指针而已。
答案：面向过程就是分析出解决问题所须要的步骤，而后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就能够了。
面向对象是把构成问题事务分解成各个对象，创建对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。；

30.类别的做用
答案：类别主要有3个做用：
(1)将类的实现分散到多个不一样文件或多个不一样框架中。
(2)建立对私有方法的前向引用。
(3)向对象添加非正式协议。
类别的局限性
有两方面局限性：
(1)没法向类中添加新的实例变量，类别没有位置容纳实例变量。
(2)名称冲突，即当类别中的方法与原始类方法名称冲突时，类别具备更高的优先级。类别方法将彻底取代初始方法从而没法再使用初始方法。
没法添加实例变量的局限能够使用字典对象解决

随着iOS平台开发的职位的增长，笔试、面试也愈来愈有“套路”，这里我总结了一些面试题，多数是Objective-C的基础知识，适合于面试新人，答案是我本身答的，不许确的地方，欢迎指出。

二

1. Object－c的类能够多重继承么？能够实现多个接口么？Category是什么？重写一个类的方式用继承好仍是分类好？为何？

答案：Object-c的类不能够多重继承；能够实现多个接口，经过实现多个接口能够完成C++的多重继承；Category是类别，通常状况用分类好，用Category去重写类的方法，仅对本Category有效，不会影响到其余类与原有类的关系。

2.#import 跟#include 又什么区别，@class呢, ＃import<> 跟 #import””又什么区别？

答案：#import是Objective-C导入头文件的关键字，#include是C/C++导入头文件的关键字,使用#import头文件会自动只导入一次，不会重复导入，至关于#include和#pragma once；@class告诉编译器某个类的声明，当执行时，才去查看类的实现文件，能够解决头文件的相互包含；#import<>用来包含系统的头文件，#import””用来包含用户头文件。

3. 属性readwrite，readonly，assign，retain，copy，nonatomic 各是什么做用，在那种状况下用？

答案：readwrite 是可读可写特性；须要生成getter方法和setter方法时

readonly 是只读特性只会生成getter方法不会生成setter方法 ;不但愿属性在类外改变

assign 是赋值特性，setter方法将传入参数赋值给实例变量；仅设置变量时；

retain 表示持有特性，setter方法将传入参数先保留，再赋值，传入参数的retaincount会+1;

copy 表示拷贝特性，setter方法将传入对象复制一份；须要彻底一份新的变量时。

nonatomic 非原子操做，决定编译器生成的setter getter是不是原子操做，atomic表示多线程安全，通常使用nonatomic

4.写一个setter方法用于完成@property （nonatomic,retain）NSString *name,写一个setter方法用于完成@property（nonatomic，copy）NSString *name

答案：[cpp] view plain copy print ?

- (void) setName:(NSString*) str
{
[str retain];
[name release];
name = str;
}
- (void)setName:(NSString *)str
{
id t = [str copy];
[name release];
name = t;
}

5.对于语句NSString*obj = [[NSData alloc] init]; obj在编译时和运行时分别时什么类型的对象？

答案：编译时是NSString的类型；运行时是NSData类型的对象

6.常见的object-c的数据类型有那些，和C的基本数据类型有什么区别？如：NSInteger和int

答案：object-c的数据类型有 NSString，NSNumber，NSArray，NSMutableArray，NSData等等，这些都是class，建立后即是对象，而C语言的基本数据类型int，只是必定字节的内存空间，用于存放数值；NSInteger是基本数据类型，并非NSNumber的子类，固然也不是 NSObject的子类。NSInteger是基本数据类型Int或者Long的别名（NSInteger的定义typedef long NSInteger），它的区别在于，NSInteger会根据系统是32位仍是64位来决定是自己是int仍是Long。

7.id 声明的对象有什么特性？

答案：Id 声明的对象具备运行时的特性，便可以指向任意类型的objcetive-c的对象；

8.Objective-C如何对内存管理的,说说你的见解和解决方法?

Objective-C的内存管理主要有三种方式ARC（自动内存计数）、手动内存计数、内存池。

9.内存管理的几条原则时什么？按照默认法则.那些关键字生成的对象

答案：须要手动释放？在和property结合的时候怎样有效的避免内存泄露？

谁申请，谁释放

遵循Cocoa Touch的使用原则；

内存管理主要要避免“过早释放”和“内存泄漏”，对于“过早释放”须要注意@property设置特性时，必定要用对特性关键字，对于“内存泄漏”，必定要申请了要负责释放，要细心。

关键字alloc 或new 生成的对象须要手动释放；

设置正确的property属性，对于retain须要在合适的地方释放.

10.如何对iOS设备进行性能测试?

Profile-> Instruments ->Time Profiler

11.看下面的程序,第一个NSLog会输出什么？这时str的retainCount是多少？第二个和第三个呢？为何？

答案：[cpp] view plain copy print ?

=======================================================
NSMutableArray* ary = [[NSMutableArray array] retain];
NSString *str = [NSString stringWithFormat:@"test"];
[strretain];
[aryaddObject:str];
NSLog(@“%@%d”,str,[str retainCount]);
[strretain];
[strrelease];
[strrelease];
NSLog(@“%@%d”,str,[str retainCount]);
[aryremoveAllObjects];
NSLog(@“%@%d”,str,[str retainCount]);
=======================================================

str的retainCount建立+1，retain+1，加入数组自动+1

retain+1，release-1，release-1

数组删除全部对象，全部数组内的对象自动-1

12. Object C中建立线程的方法是什么？若是在主线程中执行代码，方法是什么？若是想延时执行代码、方法又是什么？

答案：线程建立有三种方法：使用NSThread建立、使用GCD的dispatch、使用子类化的 NSOperation,而后将其加入NSOperationQueue;在主线程执行代码，方法是 performSelectorOnMainThread，若是想延时执行代码能够用 performSelector:onThread:withObject:waitUntilDone:

13.描述一下iOS SDK中如何实现MVC的开发模式

答案：MVC是模型、试图、控制开发模式，对于iOS SDK，全部的View都是视图层的，它应该独立于模型层，由视图控制层来控制。全部的用户数据都是模型层，它应该独立于视图。全部的ViewController都是控制层，由它负责控制视图，访问模型数据。

14.关键字volatile有什么含意?并给出三个不一样的例子：
答案：一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到
这个变量时必须每次都当心地从新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：
• 并行设备的硬件寄存器（如：状态寄存器）
• 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
• 多线程应用中被几个任务共享的变量

• 一个参数既能够是const还能够是volatile吗？解释为何。
• 一个指针能够是volatile 吗？解释为何。

下面是答案：
• 是的。一个例子是只读的状态寄存器。它是volatile由于它可能被意想不到地改变。它是const由于程序不该该试图去修改它。
• 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。

15.@synthesize 是系统自动生成getter和setter属性声明
答案：@dynamic 是开发者自已提供相应的属性声明
@dynamic 意思是由开发人员提供相应的代码：对于只读属性须要提供 setter，对于读写属性须要提供 setter 和getter。@synthesize 意思是，除非开发人员已经作了，不然由编译器生成相应的代码，以知足属性声明。
查阅了一些资料肯定@dynamic的意思是告诉编译器,属性的获取与赋值方法由用户本身实现, 不自动生成。

16.id、nil表明什么？
答案：id和void *并不是彻底同样。在上面的代码中，id是指向struct objc_object的一个指针，这个意思基本上是说，id是一个指向任何一个继承了Object（或者NSObject）类的对象。须要注意的是id 是一个指针，因此你在使用id的时候不须要加星号。好比id foo=nil定义了一个nil指针，这个指针指向NSObject的一个任意子类。而id *foo=nil则定义了一个指针，这个指针指向另外一个指针，被指向的这个指针指向NSObject的一个子类。
nil和C语言的NULL相同，在objc/objc.h中定义。nil表示一个Objctive-C对象，这个对象的指针指向空（没有东西就是空）。
首字母大写的Nil和nil有一点不同，Nil定义一个指向空的类（是Class，而不是对象）。
SEL是“selector”的一个类型，表示一个方法的名字
Method（咱们常说的方法）表示一种类型，这种类型与selector和实现(implementation)相关
IMP定义为 id (*IMP) (id, SEL, …)。这样说来， IMP是一个指向函数的指针，这个被指向的函数包括id(“self”指针)，调用的SEL（方法名），再加上一些其余参数.说白了IMP就是实现方法。

17.层和UIView的区别是什么？
答：二者最大的区别是,图层不会直接渲染到屏幕上，UIView是iOS系统中界面元素的基础，全部的界面元素都是继承自它。它自己彻底是由 CoreAnimation来实现的。它真正的绘图部分，是由一个CALayer类来管理。UIView自己更像是一个CALayer的管理器。一个 UIView上能够有n个CALayer，每一个layer显示一种东西，加强UIView的展示能力。

18.GCD为Grand Central Dispatch的缩写。
Grand Central Dispatch (GCD)是Apple开发的一个多核编程的较新的解决方法。在Mac OS X 10.6雪豹中首次推出，并在最近引入到了iOS4.0。
GCD是一个替代诸如NSThread等技术的很高效和强大的技术。GCD彻底能够处理诸如数据锁定和资源泄漏等复杂的异步编程问题。
GCD能够完成不少事情，可是这里仅关注在iOS应用中实现多线程所需的一些基础知识。
在开始以前，须要理解是要提供给GCD队列的是代码块，用于在系统或者用户建立的的队列上调度运行。
声明一个队列
以下会返回一个用户建立的队列：
dispatch_queue_t myQueue = dispatch_queue_create(“com.iphonedevblog.post”, NULL);其中，第一个参数是标识队列的，第二个参数是用来定义队列的参数（目前不支持，所以传入NULL）。
执行一个队列
以下会异步执行传入的代码：
dispatch_async(myQueue, ^{ [self doSomething]; });其中，首先传入以前建立的队列，而后提供由队列运行的代码块。
声明并执行一个队列
若是不须要保留要运行的队列的引用，能够经过以下代码实现以前的功能：　　dispatch_async(dispatch_queue_create (“com.iphonedevblog.post”, NULL), ^{ [self doSomething]; });若是须要暂停一个队列，能够调用以下代码。暂停一个队列会阻止和该队列相关的全部代码运行。　　 dispatch_suspend(myQueue);暂停一个队列
若是暂停一个队列不要忘记恢复。暂停和恢复的操做和内存管理中的retain和release相似。调用dispatch_suspend会增长暂停计数，而dispatch_resume则会减小。队列只有在暂停计数变成零的状况下才开始运行。dispatch_resume(myQueue);恢复一个队列　　从队列中在主线程运行代码有些操做没法在异步队列运行，所以必须在主线程（每一个应用都有一个）上运行。UI绘图以及任何对 NSNotificationCenter的调用必须在主线程长进行。在另外一个队列中访问主线程并运行代码的示例以下：　　 dispatch_sync(dispatch_get_main_queue(), ^{ [self dismissLoginWindow]; });注意，dispatch_suspend （以及dispatch_resume）在主线程上不起做用。
使用GCD，可让你的程序不会失去响应. 多线程不容易使用，用了GCD，会让它变得简单。你无需专门进行线程管理, 很棒！
dispatch_queue_t t1=dispatch_queue_create(“1″, NULL);
dispatch_queue_t t2=dispatch_queue_create(“2″, NULL);
dispatch_async(t1, ^{
[self print1];
});
dispatch_async(t2, ^{
[self print2];
});

19.Provider是指某个iPhone软件的Push服务器，这篇文章我将使用.net做为Provider。
答案：APNS 是Apple Push Notification Service（Apple Push服务器）的缩写，是苹果的服务器。
上图能够分为三个阶段。
第一阶段：.net应用程序把要发送的消息、目的iPhone的标识打包，发给APNS。
第二阶段：APNS在自身的已注册Push服务的iPhone列表中，查找有相应标识的iPhone，并把消息发到iPhone。
第三阶段：iPhone把发来的消息传递给相应的应用程序，而且按照设定弹出Push通知。
http://blog.csdn.net/zhuqilin0/article/details/6527113 //消息推送机制
看内存泄露时候：在搜索中搜索run 找到Run Static Snalyzer .

20.可扩展标记语言extensible markup language;XML
答案：1)用于标记电子文件使其具备结构性的标记语言，
2)能够用来标记数据、定义数据类型，是一种容许用户对本身的标记语言进行定义的源语言。
3)数据库提供了更强有力的数据存储和分析能力，例如：数据索引、排序、查找、相关一致性等，XML仅仅是存储数据。
4)XML与HTML的设计区别是：XML的核心是数据，其重点是数据的内容。而HTML 被设计用来显示数据，其重点是数据的显示。
5)XML和HTML语法区别：HTML的标记不是全部的都须要成对出现，XML则要求全部的标记必须成对出现；HTML标记不区分大小写，XML则大小敏感,即区分大小写。
结合
XML的简单使其易于在任何应用程序中读写数据，这使XML很快成为数据交换的惟一公共语言，虽然不一样的应用软件也支持其它的数据交换格式，但不久以后他们都将支持XML，那就意味着程序能够更容易的与Windows,Mac OS,Linux以及其余平台下产生的信息结合，而后能够很容易加载XML数据到程序中并分析他，并以XML格式输出结果。
XML去掉了以前令许多开发人员头疼的SGML（标准通用标记语言）的随意语法。在XML中，采用了以下的语法：
1 任何的起始标签都必须有一个结束标签。
2 能够采用另外一种简化语法，能够在一个标签中同时表示起始和结束标签。这种语法是在大于符号以前紧跟一个斜线（/），例如<tag/ >。XML解析器会将其翻译成<tag></tag>。
3 标签必须按合适的顺序进行嵌套，因此结束标签必须按镜像顺序匹配起始标签，例如this is asamplestring。这比如是将起始和结束标签看做是数学中的左右括号：在没有关闭全部的内部括号以前，是不能关闭外面的括号的。
4 全部的特性都必须有值。
5 全部的特性都必须在值的周围加上双引号。

21.代码分析
union u
{
double a;
int b;
};

union u2
{
char a[13];
int b;
};

union u3
{
char a[13];
char b;
};

cout<<sizeof(u)<<endl; // 8
cout<<sizeof(u2)<<endl; // 16
cout<<sizeof(u3)<<endl; // 13
都知道union的大小取决于它全部的成员中，占用空间最大的一个成员的大小。因此对于u来讲，大小就是最大的double类型成员a了，因此 sizeof(u)=sizeof(double)=8。可是对于u2和u3，最大的空间都是char[13]类型的数组，为何u3的大小是13，而 u2是16呢？关键在于u2中的成员int b。因为int类型成员的存在，使u2的对齐方式变成4，也就是说，u2的大小必须在4的对界上，因此占用的空间变成了16（最接近13的对界）。 struct s1
{
char a;
double b;
int c;
char d;
};

struct s2
{
char a;
char b;
int c;
double d;
};

cout<<sizeof(s1)<<endl; // 24
cout<<sizeof(s2)<<endl; // 16

一样是两个char类型，一个int类型，一个double类型，可是由于对界问题，致使他们的大小不一样。计算结构体大小能够采用元素摆放法，我举例子说明一下：首先，CPU判断结构体的对界，根据上一节的结论，s1和s2的对界都取最大的元素类型，也就是double类型的对界8。而后开始摆放每一个元素。

对于s1，首先把a放到8的对界，假定是0，此时下一个空闲的地址是1，可是下一个元素d是double类型，要放到8的对界上，离1最接近的地址是8了，因此d被放在了8，此时下一个空闲地址变成了16，下一个元素c的对界是4，16能够知足，因此c放在了16，此时下一个空闲地址变成了20，下一个元素d须要对界1，也正好落在对界上，因此d放在了20，结构体在地址21处结束。因为s1的大小须要是8的倍数，因此21- 23的空间被保留，s1的大小变成了24。

对于s2，首先把a放到8的对界，假定是0，此时下一个空闲地址是1，下一个元素的对界也是1，因此b摆放在1，下一个空闲地址变成了2；下一个元素c的对界是4，因此取离2最近的地址4摆放c，下一个空闲地址变成了8，下一个元素d的对界是 8，因此d摆放在8，全部元素摆放完毕，结构体在15处结束，占用总空间为16，正好是8的倍数。
22.ASIDownloadCache 设置下载缓存
答案：它对Get请求的响应数据进行缓存（被缓存的数据必需是成功的200请求）：
[ASIHTTPRequest setDefaultCache:[ASIDownloadCache sharedCache]];
当设置缓存策略后，全部的请求都被自动的缓存起来。
另外，若是仅仅但愿某次请求使用缓存操做，也能够这样使用：
ASIHTTPRequest *request = [ASIHTTPRequest requestWithURL:url];
[request setDownloadCache:[ASIDownloadCache sharedCache]];
缓存存储方式
你能够设置缓存的数据须要保存多长时间，ASIHTTPRequest提供了两种策略：
a，ASICacheForSessionDurationCacheStoragePolicy，默认策略，基于session的缓存数据存储。当下次运行或[ASIHTTPRequest clearSession]时，缓存将失效。
b，ASICachePermanentlyCacheStoragePolicy，把缓存数据永久保存在本地，
如：
ASIHTTPRequest *request = [ ASIHTTPRequest requestWithURL:url ];
[ request setCacheStoragePolicy:ASICachePermanentlyCacheStoragePolicy ];

23.HTTP协议详解
答案：HTTP是一个属于应用层的面向对象的协议，因为其简捷、快速的方式，适用于分布式超媒体信息系统。目前在WWW中使用的是HTTP/1.0的第六版，HTTP/1.1的规范化工做正在进行之中。
http（超文本传输协议）是一个基于请求与响应模式的、无状态的、应用层的协议，常基于TCP的链接方式，HTTP1.1版本中给出一种持续链接的机制，绝大多数的Web开发，都是构建在HTTP协议之上的Web应用。
HTTP协议的主要特色可归纳以下：
1.支持客户/服务器模式。
2.简单快速：客户向服务器请求服务时，只需传送请求方法和路径。请求方法经常使用的有GET、HEAD、POST。每种方法规定了客户与服务器联系的类型不一样。因为HTTP协议简单，使得HTTP服务器的程序规模小，于是通讯速度很快。
3.灵活：HTTP容许传输任意类型的数据对象。正在传输的类型由Content-Type加以标记。
4.无链接：无链接的含义是限制每次链接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开链接。采用这种方式能够节省传输时间。
5.无状态：HTTP协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。缺乏状态意味着若是后续处理须要前面的信息，则它必须重传，这样可能致使每次链接传送的数据量增大。另外一方面，在服务器不须要先前信息时它的应答就较快。

24.URL
答案：HTTP URL (URL是一种特殊类型的URI是他的子类，包含了用于查找某个资源的足够的信息)的格式以下：
[url=http://host[%22%22port][abs_path/]http://host[":"port][abs_path[/url]]
http表示要经过HTTP协议来定位网络资源；host表示合法的Internet主机域名或者IP地址；port指定一个端口号，为空则使用缺省端口 80；abs_path指定请求资源的URI；若是URL中没有给出abs_path，那么当它做为请求URI时，必须以“/”的形式给出，一般这个工做浏览器自动帮咱们完成。

25.TCP/UDP区别联系
答案：TCP—传输控制协议,提供的是面向链接、可靠的字节流服务。当客户和服务器彼此交换数据前，必须先在双方之间创建一个TCP链接，以后才能传输数据。TCP提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传到另外一端。
UDP—用户数据报协议，是一个简单的面向数据报的运输层协议。UDP不提供可靠性，它只是把应用程序传给IP层的数据报发送出去，可是并不能保证它们能到达目的地。因为UDP在传输数据报前不用在客户和服务器之间创建一个链接，且没有超时重发等机制，故而传输速度很快
TCP（Transmission Control Protocol，传输控制协议）是基于链接的协议，也就是说，在正式收发数据前，必须和对方创建可靠的链接。一个TCP链接必需要通过三次“对话”才能创建起来，咱们来看看这三次对话的简单过程：1.主机A向主机B发出链接请求数据包；2.主机B向主机A发送赞成链接和要求同步（同步就是两台主机一个在发送，一个在接收，协调工做）的数据包；3.主机A再发出一个数据包确认主机B的要求同步：“我如今就发，你接着吧！”，这是第三次对话。三次“对话”的目的是使数据包的发送和接收同步，通过三次“对话”以后，主机A才向主机B正式发送数据。
UDP（User Data Protocol，用户数据报协议）是与TCP相对应的协议。它是面向非链接的协议，它不与对方创建链接，而是直接就把数据包发送过去！ UDP适用于一次只传送少许数据、对可靠性要求不高的应用环境。
tcp协议和udp协议的差异
是否链接面向链接面向非链接
传输可靠性可靠不可靠
应用场合传输大量数据少许数据
速度慢快

26.socket链接和http链接的区别
答案：简单说，你浏览的网页（网址以http://开头)都是http协议传输到你的浏览器的, 而http是基于socket之上的。socket是一套完成tcp，udp协议的接口。
HTTP协议：简单对象访问协议，对应于应用层，HTTP协议是基于TCP链接的
tcp协议：对应于传输层
ip协议：对应于网络层
TCP/IP是传输层协议，主要解决数据如何在网络中传输；而HTTP是应用层协议，主要解决如何包装数据。
Socket是对TCP/IP协议的封装，Socket自己并非协议，而是一个调用接口（API），经过Socket，咱们才能使用TCP/IP协议。
http链接：http链接就是所谓的短链接，即客户端向服务器端发送一次请求，服务器端响应后链接即会断掉；
socket链接：socket链接就是所谓的长链接，理论上客户端和服务器端一旦创建起链接将不会主动断掉；可是因为各类环境因素可能会是链接断开，好比说：服务器端或客户端主机down了，网络故障，或者二者之间长时间没有数据传输，网络防火墙可能会断开该链接以释放网络资源。因此当一个socket链接中没有数据的传输，那么为了维持链接须要发送心跳消息~~具体心跳消息格式是开发者本身定义的
咱们已经知道网络中的进程是经过socket来通讯的，那什么是socket呢？socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，均可以用“打开open –> 读写write/read –> 关闭close”模式来操做。个人理解就是Socket就是该模式的一个实现，socket便是一种特殊的文件，一些socket函数就是对其进行的操做（读/写IO、打开、关闭），这些函数咱们在后面进行介绍。咱们在传输数据时，能够只使用（传输层）TCP/IP协议，可是那样的话，若是没有应用层，便没法识别数据内容，若是想要使传输的数据有意义，则必须使用到应用层协议，应用层协议有不少，好比HTTP、FTP、TELNET等，也能够本身定义应用层协议。WEB使用HTTP协议做应用层协议，以封装HTTP文本信息，而后使用TCP/IP作传输层协议将它发到网络上。
1)Socket是一个针对TCP和UDP编程的接口，你能够借助它创建TCP链接等等。而TCP和UDP协议属于传输层。
而http是个应用层的协议，它实际上也创建在TCP协议之上。
(HTTP是轿车，提供了封装或者显示数据的具体形式；Socket是发动机，提供了网络通讯的能力。)
2）Socket是对TCP/IP协议的封装，Socket自己并非协议，而是一个调用接口（API），经过Socket，咱们才能使用TCP/IP协议。Socket的出现只是使得程序员更方便地使用TCP/IP协议栈而已，是对TCP/IP协议的抽象，从而造成了咱们知道的一些最基本的函数接口。

27.什么是TCP链接的三次握手
答案：第一次握手：客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认；
第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时本身也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；
第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。
握手过程当中传送的包里不包含数据，三次握手完毕后，客户端与服务器才正式开始传送数据。理想状态下，TCP链接一旦创建，在通讯双方中的任何一方主动关闭链接以前，TCP 链接都将被一直保持下去。断开链接时服务器和客户端都可以主动发起断开TCP链接的请求，断开过程须要通过“四次握手”（过程就不细写了，就是服务器和客户端交互，最终肯定断开）

28.利用Socket创建网络链接的步骤
答案：创建Socket链接至少须要一对套接字，其中一个运行于客户端，称为ClientSocket ，另外一个运行于服务器端，称为ServerSocket 。
套接字之间的链接过程分为三个步骤：服务器监听，客户端请求，链接确认。
1。服务器监听：服务器端套接字并不定位具体的客户端套接字，而是处于等待链接的状态，实时监控网络状态，等待客户端的链接请求。
2。客户端请求：指客户端的套接字提出链接请求，要链接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要链接的服务器的套接字，指出服务器端套接字的地址和端口号，而后就向服务器端套接字提出链接请求。
3。链接确认：当服务器端套接字监听到或者说接收到客户端套接字的链接请求时，就响应客户端套接字的请求，创建一个新的线程，把服务器端套接字的描述发给客户端，一旦客户端确认了此描述，双方就正式创建链接。而服务器端套接字继续处于监听状态，继续接收其余客户端套接字的链接请求。

29.进程与线程
答案：进程（process）是一块包含了某些资源的内存区域。操做系统利用进程把它的工做划分为一些功能单元。
进程中所包含的一个或多个执行单元称为线程（thread）。进程还拥有一个私有的虚拟地址空间，该空间仅能被它所包含的线程访问。
一般在一个进程中能够包含若干个线程，它们能够利用进程所拥有的资源。
在引入线程的操做系统中，一般都是把进程做为分配资源的基本单位，而把线程做为独立运行和独立调度的基本单位。
因为线程比进程更小，基本上不拥有系统资源，故对它的调度所付出的开销就会小得多，能更高效的提升系统内多个程序间并发执行的程度。
简而言之,一个程序至少有一个进程,一个进程至少有一个线程.一个程序就是一个进程，而一个程序中的多个任务则被称为线程。
线程只能归属于一个进程而且它只能访问该进程所拥有的资源。当操做系统建立一个进程后，该进程会自动申请一个名为主线程或首要线程的线程。应用程序（application）是由一个或多个相互协做的进程组成的。
另外，进程在执行过程当中拥有独立的内存单元，而多个线程共享内存，从而极大地提升了程序的运行效率。
线程在执行过程当中与进程仍是有区别的。每一个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。可是线程不可以独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分能够同时执行。但操做系统并无将多个线程看作多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
进程是具备必定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程本身基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),可是它可与同属一个进程的其余的线程共享进程所拥有的所有资源.
一个线程能够建立和撤销另外一个线程;同一个进程中的多个线程之间能够并发执行.

30.多线程
答案：多线程编程是防止主线程堵塞，增长运行效率等等的最佳方法。而原始的多线程方法存在不少的毛病，包括线程锁死等。在Cocoa中，Apple提供了NSOperation这个类，提供了一个优秀的多线程编程方法。
本次介绍NSOperation的子集，简易方法的NSInvocationOperation：
一个NSOperationQueue 操做队列，就至关于一个线程管理器，而非一个线程。由于你能够设置这个线程管理器内能够并行运行的的线程数量等等

三

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?
oc中的协议和java中的接口概念有何不一样？
答案：OC中的协议有2层含义，官方定义为 formal和informal protocol。前者和Java接口同样。
informal protocol中的方法属于设计模式考虑范畴，不是必须实现的，可是若是有实现，就会改变类的属性。
其实关于正式协议，类别和非正式协议我很早前学习的时候大体看过，也写在了学习教程里
“非正式协议概念其实就是类别的另外一种表达方式“这里有一些你可能但愿实现的方法，你能够使用他们更好的完成工做”。
这个意思是，这些是可选的。好比我门要一个更好的方法，咱们就会申明一个这样的类别去实现。而后你在后期能够直接使用这些更好的方法。
这么看，总以为类别这玩意儿有点像协议的可选协议。”
如今来看，其实protocal已经开始对二者都统一和规范起来操做，由于资料中说“非正式协议使用interface修饰“，
如今咱们看到协议中两个修饰词：“必须实现(@requied)”和“可选实现(@optional)”。

OC中的协议(formal protocol)与java中的接口概念基本一致，OC中非正式协议(informal protocol)就是类别。在java中若是继承了接口，但不实现其方法，会获得一个error（没法编译）；在OC中的正式协议，若是不实现，会获得一个warning（可编译执行），若是想去除waring，还能够加关键字（@optional），让它可选实现方法。

#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 异常错误。

(cocoachina.com注：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?
oc中可修改和不能够修改类型。
答案：可修改不可修改的集合类。这个我我的简单理解就是可动态添加修改和不可动态添加修改同样。
好比NSArray和NSMutableArray。前者在初始化后的内存控件就是固定不可变的，后者能够添加等，能够动态申请新的内存空间。

8.When we call objective c is runtime language what does it mean?
咱们说的oc是动态运行时语言是什么意思？
答案：多态。主要是将数据类型的肯定由编译时，推迟到了运行时。
这个问题其实浅涉及到两个概念，运行时和多态。
简单来讲，运行时机制使咱们直到运行时才去决定一个对象的类别，以及调用该类别对象指定方法。
多态：不一样对象以本身的方式响应相同的消息的能力叫作多态。意思就是假设生物类（life）都用有一个相同的方法-eat;
那人类属于生物，猪也属于生物，都继承了life后，实现各自的eat，可是调用是咱们只需调用各自的eat方法。
也就是不一样的对象以本身的方式响应了相同的消息（响应了eat这个选择器）。
所以也能够说，运行时机制是多态的基础？~~~

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

10.What is push notification?
什么是推送消息？
答案：太简单，不做答~~~~~~~~~~
这是cocoa上的答案。
其实到不是说太简单，只是太泛泛的一个概念的东西。就比如说，什么是人。
推送通知更是一种技术。
简单点就是客户端获取资源的一种手段。
普通状况下，都是客户端主动的pull。
推送则是服务器端主动push。测试push的实现能够查看该博文。

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.?
OC的垃圾回收机制？
答案： OC2.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~
综合一点，咱们知道他能够比较大的用处在于能够帮助多线程编程就行了。

楼上区分了线程执行时的次序（Afunc和Bfunc谁先启动）和线程执行完成（Afunc和Bfunc谁先执行完）时的次序不一样，而多线程的重要概念是并发（同时执行多个任务），NSOperationQueue是管理并发线程的对象，能够在其中放入NSOpertation对象（对象化的线程实体），经过设置maxConcurrentOperationCount的大小，控制并发数目，如楼上所说但愿“Afunc添加进队列，执行完后，Bfunc紧跟进入队列，继续执行”，那只需将maxConcurrentOperationCount设为1，变会依次执行，这时候实际是在单线程依次执行。因此这里的NSOperationQueue就是对象化抽象的去管理多线程，这样的好处，使用者经过继承NSOperation对象，能够方便的用对象来管理线程，而再也不用关心线程同步、信号量等细节，更多地关注于业务逻辑。

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是否能够关联两个不一样的数据源？你会怎么处理？
答案：首先咱们从代码来看，数据源如何关联上的，实际上是在数据源关联的代理方法里实现的。
所以咱们并不关心如何去关联他，他怎么关联上，方法只是让我返回根据本身的须要去设置如相关的数据源。
所以，我以为能够设置多个数据源啊，可是有个问题是，你这是想干吗呢？想让列表如何显示，不一样的数据源分区块显示？

四

1.When to use NSMutableArray and when to use NSArray?

何时使用NSMutableArray，何时使用NSArray？

答案：当数组在程序运行时，须要不断变化的，使用NSMutableArray，当数组在初始化后，便再也不改变的，使用NSArray。须要指出的是，使用NSArray只代表的是该数组在运行时不发生改变，即不能往NSAarry的数组里新增和删除元素，但不代表其数组內的元素的内容不能发生改变。NSArray是线程安全的，NSMutableArray不是线程安全的，多线程使用到NSMutableArray须要注意。

2.Give us example of what are delegate methods and what are data source methods of uitableview.

给出委托方法的实例，而且说出UITableVIew的Data Source方法

答案：CocoaTouch框架中用到了大量委托，其中UITableViewDelegate就是委托机制的典型应用，是一个典型的使用委托来实现适配器模式，其中UITableViewDelegate协议是目标，tableview是适配器，实现UITableViewDelegate协议，并将自身设置为talbeview的delegate的对象，是被适配器，通常状况下该对象是UITableViewController。

UITableVIew的Data Source方法有- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section;

– (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath;

3.How many autorelease you can create in your application? Is there any limit?

在应用中能够建立多少autorelease对象，是否有限制？

答案：无

4.If we don’t create any autorelease pool in our application then is there any autorelease pool already provided to us?

若是咱们不建立内存池，是否有内存池提供给咱们？

答案:界面线程维护着本身的内存池，用户本身建立的数据线程，则须要建立该线程的内存池

5.When you will create an autorelease pool in your application?

何时须要在程序中建立内存池？

答案：用户本身建立的数据线程，则须要建立该线程的内存池

6.When retain count increase?

何时内存计数会增长？

答案：应聘ios开发工程师常见的面试题(二)

7.What are commonly used NSObject class methods?

类NSObject的那些方法常常被使用？

答案：NSObject是Objetive-C的基类，其由NSObject类及一系列协议构成。

其中类方法alloc、class、 description 对象方法init、dealloc、– performSelector:withObject:afterDelay:等常常被使用

8.What is convenience constructor?

什么是简便构造方法？

答案：简便构造方法通常由CocoaTouch框架提供，如NSNumber 的 + numberWithBool: + numberWithChar: + numberWithDouble: + numberWithFloat: + numberWithInt:

Foundation下大部分类均有简便构造方法，咱们能够经过简便构造方法，得到系统给咱们建立好的对象，而且不须要手动释放。

9.How to design universal application in Xcode?

如何使用Xcode设计通用应用？

答案：使用MVC模式设计应用，其中Model层完成脱离界面，即在Model层，其是可运行在任何设备上，在controller层，根据iPhone与iPad（独有 UISplitViewController）的不一样特色选择不一样的viewController对象。在View层，可根据现实要求，来设计，其中以 xib文件设计时，其设置其为universal。

10.What is keyword atomic in Objective C?

在Objetive-C什么时原子关键字

答案：atomic，nonatomic 详见应聘ios开发工程师常见的面试题(二)

11.What are UIView animations?

UIView的动画效果有那些？

答案：有不少，如 UIViewAnimationOptionCurveEaseInOut UIViewAnimationOptionCurveEaseIn UIViewAnimationOptionCurveEaseOut UIViewAnimationOptionTransitionFlipFromLeft UIViewAnimationOptionTransitionFlipFromRight UIViewAnimationOptionTransitionCurlUpUIViewAnimationOptionTransitionCurlDown

12.How can you store data in iPhone applications?

在iPhone应用中如何保存数据？

答案：有如下几种保存机制：

1.经过web服务，保存在服务器上

2.经过NSCoder固化机制，将对象保存在文件中

3.经过SQlite或CoreData保存在文件数据库中

13.What is coredata?

什么是coredata？

答案：coredata框架是apple提供的一套通用自动的解决方案，包括了对象生存周期、对象关系图、持久化机制。

补充答案：上面是翻译的，按我我的理解coredata提供一种一机制，让咱们能够方便的把内存中对象，及对象间的关系，映射到coredata，而后由它为咱们持久化数据。相比普通的文件数据库SQlite，它的功能更强大，不须要咱们先将对象数据format成SQL语句，存入数据库，再用 select语句读出，而如今是从内存到coredata的数据管理，咱们只需管理coredata的managed对象。

是苹果提供一套数据保存

14.What is NSManagedObject model?

什么是NSManagedObject模型？

答案：NSManagedObject是NSObject的子类，也是coredata的重要组成部分，它是一个通用的类,实现了core data 模型层所需的基本功能，用户可经过子类化NSManagedObject，创建本身的数据模型。

15.What is NSManagedobjectContext?

什么是NSManagedobjectContext？

答案：NSManagedobjectContext对象负责应用和数据库之间的交互。

16.What is predicate?

什么是谓词？

答案：谓词是经过NSPredicate，是经过给定的逻辑条件做为约束条件，完成对数据的筛选。

predicate = [NSPredicate predicateWithFormat:@"customerID == %d",n];

a = [customers filteredArrayUsingPredicate:predicate];

17.What kind of persistence store we can use with coredata?

coredata有哪几种持久化存储机制？

答案：coredatat提供如下几种存储机制：XML（iOS系统不支持）,自动存储,SQLite,内存存储。

补充说明：这个问题问的是，coredate框架的存储机制，平时使用coredata时，更多关注的是managed的对象，这里是coerdata框架的存储实现细节。BTW: 其余经常使用的持久化存储方法：存入到文件、存入到NSUserDefaults（系统plist文件中）。

18 谈谈对Block 的理解？并写出一个使用Block执行UIVew动画？

答案：Block是能够获取其余函数局部变量的匿名函数，其不但方便开发，而且能够大幅提升应用的执行效率（多核心CPU可直接处理Block指令）

[cpp] view plaincopyprint?

[UIView transitionWithView:self.view
duration:0.2
options:UIViewAnimationOptionTransitionFlipFromLeft
animations:^{ [[blueViewController view] removeFromSuperview]; [[self view] insertSubview:yellowViewController.view atIndex:0]; }
completion:NULL];

19 写出上面代码的Block的定义。

答案：

typedef void(^animations) (void);

typedef void(^completion) (BOOL finished);

20 试着使用+ beginAnimations:context:以及上述Block的定义，写出一个能够完成

+ (void)transitionWithView:(UIView *)view duration:(NSTimeInterval)duration options:(UIViewAnimationOptions)options animations:(void (^)(void))animations completion:(void (^)(BOOL finished))completion NS_AVAILABLE_IOS(4_0);操做的函数执行部分

答案：网络部分

21 作过的项目是否涉及网络访问功能，使用什么对象完成网络功能？

答案：ASIHTTPRequest与NSURLConnection

22 简单介绍下NSURLConnection类及+ sendSynchronousRequest:returningResponse:error:与– initWithRequest:delegate:两个方法的区别？

答案: NSURLConnection主要用于网络访问，其中+ sendSynchronousRequest:returningResponse:error:是同步访问数据，即当前线程会阻塞，并等待 request的返回的response，而– initWithRequest:delegate:使用的是异步加载，当其完成网络访问后，会经过 delegate回到主线程，并其委托的对象。

五

试题1：

void test1()
{
char string[10];
char* str1 = “0123456789”;
strcpy( string, str1 );
}
试题2：

void test2()
{
char string[10], str1[10];
int i;
for(i=0; i<10; i++)
{
str1 = ‘a';
}
strcpy( string, str1 );
}
试题3：

void test3(char* str1)
{
char string[10];
if( strlen( str1 ) <= 10 )
{
strcpy( string, str1 );
}
}
解答：

试题1字符串str1须要11个字节才能存放下（包括末尾的’\0’），而string只有10个字节的空间，strcpy会致使数组越界；

对试题2，若是面试者指出字符数组str1不能在数组内结束能够给3分；若是面试者指出strcpy(string, str1)调用使得从str1[url=]内存[/url]起复制到string内存起所复制的字节数具备不肯定性能够给7分，在此基础上指出库函数 strcpy工做方式的给10分；

对试题3，if(strlen(str1) <= 10)应改成if(strlen(str1) < 10)，由于strlen的结果未统计’\0’所占用的1个字节。

剖析：

考查对基本功的掌握：

(1)字符串以’\0’结尾；

(2)对数组越界把握的敏感度；

(3)库函数strcpy的工做方式，若是编写一个标准strcpy函数的总分值为10，下面给出几个不一样得分的答案：

2分

void strcpy( char *strDest, char *strSrc )
{
while( (*strDest++ = * strSrc++) != ‘\0’ );
}
4分

void strcpy( char *strDest, const char *strSrc )
//将源字符串加const，代表其为输入参数，加2分
{
while( (*strDest++ = * strSrc++) != ‘\0’ );
}
7分

void strcpy(char *strDest, const char *strSrc)
{
//对源地址和目的地址加非0断言，加3分
assert( (strDest != NULL) && (strSrc != NULL) );
while( (*strDest++ = * strSrc++) != ‘\0’ );
}
10分

//为了实现链式操做，将目的地址返回，加3分！

char * strcpy( char *strDest, const char *strSrc )
{
assert( (strDest != NULL) && (strSrc != NULL) );
char *address = strDest;
while( (*strDest++ = * strSrc++) != ‘\0’ );
return address;
}
从2分到10分的几个答案咱们能够清楚的看到，小小的strcpy居然暗藏着这么多玄机，真不是盖的！须要多么扎实的基本功才能写一个完美的strcpy啊！

(4)对strlen的掌握，它没有包括字符串末尾的’\0’。

读者看了不一样分值的strcpy版本，应该也能够写出一个10分的strlen函数了，完美的版本为： int strlen( const char *str ) //输入参数const

{
assert( strt != NULL ); //断言字符串地址非0
int len;
while( (*str++) != ‘\0′ )
{
len++;
}
return len;
}
试题4：

void GetMemory( char *p )
{
p = (char *) malloc( 100 );
}

void Test( void )
{
char *str = NULL;
GetMemory( str );
strcpy( str, “hello world” );
printf( str );
}
试题5：

char *GetMemory( void )
{
char p[] = “hello world”;
return p;
}

void Test( void )
{
char *str = NULL;
str = GetMemory();
printf( str );
}
试题6：

void GetMemory( char **p, int num )
{
*p = (char *) malloc( num );
}

void Test( void )
{
char *str = NULL;
GetMemory( &str, 100 );
strcpy( str, “hello” );
printf( str );
}
试题7：

void Test( void )
{
char *str = (char *) malloc( 100 );
strcpy( str, “hello” );
free( str );
… //省略的其它语句
}
解答：

试题4传入中GetMemory( char *p )函数的形参为字符串指针，在函数内部修改形参并不能真正的改变传入形参的值，执行完

char *str = NULL;
GetMemory( str );
后的str仍然为NULL；

试题5中

char p[] = “hello world”;
return p;
的p[]数组为函数内的局部自动变量，在函数返回后，内存已经被释放。这是许多程序员常犯的错误，其根源在于不理解变量的生存期。

试题6的GetMemory避免了试题4的问题，传入GetMemory的参数为字符串指针的指针，可是在GetMemory中执行申请内存及赋值语句

*p = (char *) malloc( num );
后未判断内存是否申请成功，应加上：

if ( *p == NULL )
{
…//进行申请内存失败处理
}
试题7存在与试题6一样的问题，在执行

char *str = (char *) malloc(100);
后未进行内存是否申请成功的判断；另外，在free(str)后未置str为空，致使可能变成一个“野”指针，应加上：

str = NULL;
试题6的Test函数中也未对malloc的内存进行释放。

剖析：

试题4～7考查面试者对内存操做的理解程度，基本功扎实的面试者通常都能正确的回答其中50~60的错误。可是要彻底解答正确，却也绝非易事。

对内存操做的考查主要集中在：

（1）指针的理解；

（2）变量的生存期及做用范围；

（3）良好的动态内存申请和释放习惯。

再看看下面的一段程序有什么错误：

swap( int* p1,int* p2 )
{
int *p;
*p = *p1;
*p1 = *p2;
*p2 = *p;
}
在swap函数中，p是一个“野”指针，有可能指向系统区，致使程序运行的崩溃。在VC++中DEBUG运行时提示错误“Access Violation”。该程序应该改成：

swap( int* p1,int* p2 )
{
int p;
p = *p1;
*p1 = *p2;
*p2 = p;
}[img=12,12]file:///D:/鱼鱼软件/鱼鱼多媒体日记本/temp/{56068A28-3D3B-4D8B-9F82- AC1C3E9B128C}_arc_d[1].gif[/img] 3.内功题　　试题1：分别给出BOOL，int，float，指针变量与“零值”比较的 if 语句（假设变量名为var）

解答：

BOOL型变量：if(!var)

int型变量： if(var==0)

float型变量：

const float EPSINON = 0.00001;

if ((x >= – EPSINON) && (x <= EPSINON)

指针变量：　　if(var==NULL)

剖析：

考查对0值判断的“内功”，BOOL型变量的0判断彻底能够写成if(var==0)，而int型变量也能够写成if(!var)，指针变量的判断也能够写成if(!var)，上述写法虽然程序都能正确运行，可是未能清晰地表达程序的意思。
通常的，若是想让if判断一个变量的“真”、“假”，应直接使用if(var)、if(!var)，代表其为“逻辑”判断；若是用if判断一个数值型变量 (short、int、long等)，应该用if(var==0)，代表是与0进行“数值”上的比较；而判断指针则适宜用if(var==NULL)，这是一种很好的编程习惯。

浮点型变量并不精确，因此不可将float变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。若是写成if (x == 0.0)，则判为错，得0分。

试题2：如下为Windows NT下的32位C++程序，请计算sizeof的值

void Func ( char str[100] )
{
sizeof( str ) = ?
}

void *p = malloc( 100 );
sizeof ( p ) = ?
解答：

sizeof( str ) = 4
sizeof ( p ) = 4
剖析：

Func ( char str[100] )函数中数组名做为函数形参时，在函数体内，数组名失去了自己的内涵，仅仅只是一个指针；在失去其内涵的同时，它还失去了其常量特性，能够做自增、自减等操做，能够被修改。

数组名的本质以下：

（1）数组名指代一种数据结构，这种数据结构就是数组；

例如：

char str[10];
cout ＜＜ sizeof(str) ＜＜ endl;
输出结果为10，str指代数据结构char[10]。

（2）数组名能够转换为指向其指代实体的指针，并且是一个指针常量，不能做自增、自减等操做，不能被修改；

char str[10];
str++; //编译出错，提示str不是左值
（3）数组名做为函数形参时，沦为普通指针。

Windows NT 32位平台下，指针的长度（占用内存的大小）为4字节，故sizeof( str ) 、sizeof ( p ) 都为4。

试题3：写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。另外，当你写下面的代码时会发生什么事？

least = MIN(*p++, b);
解答：

#define MIN(A,B) ((A) <= (B) ? (A) : (B))
MIN(*p++, b)会产生宏的反作用

剖析：

这个面试题主要考查面试者对宏定义的使用，宏定义能够实现相似于函数的功能，可是它终归不是函数，而宏定义中括弧中的“参数”也不是真的参数，在宏展开的时候对“参数”进行的是一对一的替换。

程序员对宏定义的使用要很是当心，特别要注意两个问题：

（1）谨慎地将宏定义中的“参数”和整个宏用用括弧括起来。因此，严格地讲，下述解答：

#define MIN(A,B) (A) <= (B) ? (A) : (B)
#define MIN(A,B) (A <= B ? A : B )
都应判0分；

（2）防止宏的反作用。

宏定义#define MIN(A,B) ((A) <= (B) ? (A) : (B))对MIN(*p++, b)的做用结果是：

((*p++) <= (b) ? (*p++) : (*p++))

这个表达式会产生反作用，指针p会做三次++自增操做。

除此以外，另外一个应该判0分的解答是：

#define MIN(A,B) ((A) <= (B) ? (A) : (B));
这个解答在宏定义的后面加“;”，显示编写者对宏的概念模糊不清，只能被无情地判0分并被面试官淘汰。

试题4：为何标准头文件都有相似如下的结构？

#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus

extern “C” {
#endif
/*…*/
#ifdef __cplusplus
}

#endif
#endif /* __INCvxWorksh */
解答：

头文件中的编译宏

#ifndef　__INCvxWorksh
#define　__INCvxWorksh
#endif
的做用是防止被重复引用。

做为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在symbol库中的名字与C语言的不一样。例如，假设某个函数的原型为：

void foo(int x, int y);
该函数被C编译器编译后在symbol库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。_foo_int_int这样的名字包含了函数名和函数参数数量及类型信息，C++就是考这种机制来实现函数重载的。

为了实现C和C++的混合编程，C++提供了C链接交换指定符号extern “C”来解决名字匹配问题，函数声明前加上extern “C”后，则编译器就会按照C语言的方式将该函数编译为_foo，这样C语言中就能够调用C++的函数了。[img=12,12]file:///D:/鱼鱼软件/鱼鱼多媒体日记本/temp/{C74A38C4-432E-4799-B54D-73E2CD3C5206}_arc_d[1].gif[/img]
试题5：编写一个函数，做用是把一个char组成的字符串循环右移n个。好比原来是“abcdefghi”若是n=2，移位后应该是“hiabcdefgh”

函数头是这样的：

//pStr是指向以’\0’结尾的字符串的指针
//steps是要求移动的n

void LoopMove ( char * pStr, int steps )
{
//请填充…
}
解答：

正确解答1：

void LoopMove ( char *pStr, int steps )
{
int n = strlen( pStr ) – steps;
char tmp[MAX_LEN];
strcpy ( tmp, pStr + n );
strcpy ( tmp + steps, pStr);
*( tmp + strlen ( pStr ) ) = ‘\0′;
strcpy( pStr, tmp );
}
正确解答2：

void LoopMove ( char *pStr, int steps )
{
int n = strlen( pStr ) – steps;
char tmp[MAX_LEN];
memcpy( tmp, pStr + n, steps );
memcpy(pStr + steps, pStr, n );
memcpy(pStr, tmp, steps );
}
剖析：

这个试题主要考查面试者对标准库函数的熟练程度，在须要的时候引用库函数能够很大程度上简化程序编写的工做量。

最频繁被使用的库函数包括：

（1） strcpy

（2） memcpy

（3） memset

六

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?oc中的协议和java中的接口概念有何不一样？
答案：OC中的代理有2层含义，官方定义为 formal和informal protocol。前者和Java接口同样。
informal protocol中的方法属于设计模式考虑范畴，不是必须实现的，可是若是有实现，就会改变类的属性。
其实关于正式协议，类别和非正式协议我很早前学习的时候大体看过，也写在了学习教程里
“非正式协议概念其实就是类别的另外一种表达方式“这里有一些你可能但愿实现的方法，你能够使用他们更好的完成工做”。
这个意思是，这些是可选的。好比我门要一个更好的方法，咱们就会申明一个这样的类别去实现。而后你在后期能够直接使用这些更好的方法。
这么看，总以为类别这玩意儿有点像协议的可选协议。”
如今来看，其实protocal已经开始对二者都统一和规范起来操做，由于资料中说“非正式协议使用interface修饰“，
如今咱们看到协议中两个修饰词：“必须实现(@requied)”和“可选实现(@optional)”。

5.What are KVO and KVC?
答案：kvc:键 – 值编码是一种间接访问对象的属性使用字符串来标识属性，而不是经过调用存取方法，直接或经过实例变量访问的机制。
不少状况下能够简化程序代码。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 异常错误。
(cocoachina.com注：Key-Value Coding查找方法的时候，不只仅会查找someKey这个方法，还会查找getsomeKey这个方法，前面加一个get，或者_someKey以及 _getsomeKey这几种形式。同时，查找实例变量的时候也会不只仅查找someKey这个变量，也会查找_someKey这个变量是否存在。）
设计valueForUndefinedKey:方法的主要目的是当你使用-(id)valueForKey方法从对象中请求值时，对象可以在错误发生前，有最后的机会响应这个请求。这样作有不少好处，下面的两个例子说明了这样作的好处。“
来至cocoa，这个说法应该挺有道理。
由于咱们知道button倒是存在一个highlighted实例变量.所以为什么上面咱们只是add一个相关的keypath就好了，

6.What is purpose of delegates?代理的做用？
答案：代理的目的是改变或传递控制链。容许一个类在某些特定时刻通知到其余类，而不须要获取到那些类的指针。能够减小框架复杂度。
另一点，代理能够理解为java中的回调监听机制的一种相似。

7.What are mutable and immutable types in Objective C?oc中可修改和不能够修改类型。
答案：可修改不可修改的集合类。这个我我的简单理解就是可动态添加修改和不可动态添加修改同样。
好比NSArray和NSMutableArray。前者在初始化后的内存控件就是固定不可变的，后者能够添加等，能够动态申请新的内存空间

8.When we call objective c is runtime language what does it mean?咱们说的oc是动态运行时语言是什么意思？
答案：多态。主要是将数据类型的肯定由编译时，推迟到了运行时。
这个问题其实浅涉及到两个概念，运行时和多态。
简单来讲，运行时机制使咱们直到运行时才去决定一个对象的类别，以及调用该类别对象指定方法。
多态：不一样对象以本身的方式响应相同的消息的能力叫作多态。意思就是假设生物类（life）都用有一个相同的方法-eat;
那人类属于生物，猪也属于生物，都继承了life后，实现各自的eat，可是调用是咱们只需调用各自的eat方法。
也就是不一样的对象以本身的方式响应了相同的消息（响应了eat这个选择器）。
所以也能够说，运行时机制是多态的基础？~~~

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

10.What is push notification?什么是推送消息？
答案：太简单，不做答~~~~~~~~~~
这是cocoa上的答案。
其实到不是说太简单，只是太泛泛的一个概念的东西。就比如说，什么是人。
推送通知更是一种技术。
简单点就是客户端获取资源的一种手段。
普通状况下，都是客户端主动的pull。
推送则是服务器端主动push。

12.What is responder chain?
说说响应链
答案：事件响应链。包括点击事件，画面刷新事件等。在视图栈内从上至下，或者从下之上传播。
能够说点事件的分发，传递以及处理。具体能够去看下touch事件这块。由于问的太抽象化了
严重怀疑题目出到越后面就越笼统。

13.Difference between frame and bounds?
frame和bounds有什么不一样？
答案:frame指的是：该view在父view坐标系统中的位置和大小。（参照点是父亲的坐标系统）
bounds指的是：该view在自己坐标系统中的位置和大小。（参照点是自己坐标系统）

14.Difference between method and selector?
方法和选择器有何不一样？
答案：selector是一个方法的名字，method是一个组合体，包含了名字和实现.

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

16.What is lazy loading?
答案：懒汉模式，只在用到的时候才去初始化。
也能够理解成延时加载。
我以为最好也最简单的一个列子就是tableView中图片的加载显示了。
一个延时载，避免内存太高，一个异步加载，避免线程堵塞。

17.Can we use two tableview controllers on one viewcontroller?
是否在一个视图控制器中嵌入两个tableview控制器？
答案：一个视图控制只提供了一个View视图，理论上一个tableViewController也不能放吧，
只能说能够嵌入一个tableview视图。固然，题目自己也有歧义，若是不是咱们定性思惟认为的UIViewController，
而是宏观的表示视图控制者，那咱们却是能够把其当作一个视图控制者，它能够控制多个视图控制器，好比TabbarController
那样的感受。

18.Can we use one tableview with two different datasources? How you will achieve this?
一个tableView是否能够关联两个不一样的数据源？你会怎么处理？
答案：首先咱们从代码来看，数据源如何关联上的，实际上是在数据源关联的代理方法里实现的。
所以咱们并不关心如何去关联他，他怎么关联上，方法只是让我返回根据本身的须要去设置如相关的数据源。
所以，我以为能够设置多个数据源啊，可是有个问题是，你这是想干吗呢？想让列表如何显示，不一样的数据源分区块显示？

七

1.请写一个C函数，若处理器是Big_endian的，则返回0；如果Little_endian的，则返回1 int checkCPU( ) {
{
union w
{
int a;
char b;
} c;
c.a = 1;
return (c.b ==1);
}
}
答案：嵌入式系统开发者应该对Little-endian和Big-endian模式很是了解。采用Little-endian模式的CPU对操做数的存放方式是从低字节到高字节， Big-endian 模式的CPU对操做数的存放方式是从高字节到低字节。在弄清楚这个以前要弄清楚这个问题：字节从右到坐为从高到低! 假设从地址0x4000开始存放: 0x12345678,是也个32位四个字节的数据，最高字节是0x12,最低字节是0x78：在Little-endian模式CPU内存中的存放方式为： (高字节在高地址, 低字节在低地址)
内存地址0x4000 0x4001 0x4002 0x4003
存放内容 0x78 0x56 0x34 0x12
大端机则相反。

有的处理器系统采用了小端方式进行数据存放，如Intel的奔腾。有的处理器系统采用了大端方式进行数据存放，如IBM半导体和Freescale的PowerPC处理器。不只对于处理器，一些外设的设计中也存在着使用大端或者小端进行数据存放的选择。所以在一个处理器系统中，有可能存在大端和小端模式同时存在的现象。这一现象为系统的软硬件设计带来了不小的麻烦，这要求系统设计工程师，必须深刻理解大端和小端模式的差异。大端与小端模式的差异体如今一个处理器的寄存器，指令集，系统总线等各个层次中。联合体union的存放顺序是全部成员都从低地址开始存放的。以上是网上的原文。让咱们看看在ARM处理器上union是如何存储的呢? 地址A —————- |A |A+1 |A+2 |A+3 |int a; | | | | ——————– |A |char b; | | ——— 若是是小端如何存储c.a的呢？
地址A ———–
——————- |A |A+1 |A+2 |A+3 | int a;
|0x01 |0x00 |0x00 |0x00 | ————————————- |A |char b; | | ———
若是是大端如何存储c.a的呢？
地址A ———————
——— |A |A+1 |A+2 |A+3 |int a; |0x00 |0x00 |0x00 |0x01 | —————————————— |A |char b; | | ——— 如今知道为何c.b==0的话是大端，c.b==1的话就是小端了吧。

2.堆和栈上的指针
答案：指针所指向的这块内存是在哪里分配的,在堆上称为堆上的指针,在栈上为栈上的指针.
在堆上的指针,能够保存在全局数据结构中,供不一样函数使用访问同一块内存.
在栈上的指针,在函数退出后,该内存即不可访问.

3.什么是指针的释放?
答案：具体来讲包括两个概念.
1 释放该指针指向的内存,只有堆上的内存才须要咱们手工释放,栈上不须要.
2 将该指针重定向为NULL.

4.数据结构中的指针?
答案：其实就是指向一块内存的地址,经过指针传递,可实现复杂的内存访问.

5.函数指针?
答案：指向一块函数的入口地址.

6.指针做为函数的参数?
答案：好比指向一个复杂数据结构的指针做为函数变量
这种方法避免整个复杂数据类型内存的压栈出栈操做,提升效率.
注意:指针自己不可变,但指针指向的数据结构能够改变.

7.指向指针的指针?
答案：指针指向的变量是一个指针,即具体内容为一个指针的值,是一个地址.
此时指针指向的变量长度也是4位.

8.指针与地址的区别?
答案：区别:
1指针意味着已经有一个指针变量存在,他的值是一个地址,指针变量自己也存放在一个长度为四个字节的地址当中,而地址概念自己并不表明有任何变量存在.
2 指针的值,若是没有限制,一般是能够变化的,也能够指向另一个地址.
地址表示内存空间的一个位置点,他是用来赋给指针的,地址自己是没有大小概念,指针指向变量的大小,取决于地址后面存放的变量类型.

9.指针与数组名的关系?
答案：其值都是一个地址,但前者是能够移动的,后者是不可变的.

10.怎样防止指针的越界使用问题?
答案：必须让指针指向一个有效的内存地址,
1 防止数组越界
2 防止向一块内存中拷贝过多的内容
3 防止使用空指针
4 防止改变const修改的指针
5 防止改变指向静态存储区的内容
6 防止两次释放一个指针
7 防止使用野指针.
11.指针的类型转换?
答案：指针转换一般是指针类型和void * 类型以前进行强制转换,从而与指望或返回void指针的函数进行正确的交接.

12.static有什么用途？（请至少说明两种）
答案：1.限制变量的做用域
2.设置变量的存储域

13.引用与指针有什么区别？
答案： 1) 引用必须被初始化，指针没必要。
2) 引用初始化之后不能被改变，指针能够改变所指的对象。
3) 不存在指向空值的引用，可是存在指向空值的指针。

14.描述实时系统的基本特性
答案：在特定时间内完成特定的任务，实时性与可靠性

15.全局变量和局部变量在内存中是否有区别？若是有，是什么区别？
答案：全局变量储存在静态数据库，局部变量在堆栈

16.什么是平衡二叉树？
答案：左右子树都是平衡二叉树且左右子树的深度差值的绝对值不大于1

17.堆栈溢出通常是由什么缘由致使的？
答案：没有回收垃圾资源

18.什么函数不能声明为虚函数？
答案：constructor

19. 冒泡排序算法的时间复杂度是什么？
答案：O(n^2)

20. 写出float x 与“零值”比较的if语句。
答案：if(x>0.000001&&x<-0.000001)

21. Internet采用哪一种网络协议？该协议的主要层次结构？
答案：tcp/ip 应用层/传输层/网络层/数据链路层/物理层

22. Internet物理地址和IP地址转换采用什么协议？
答案：ARP (Address Resolution Protocol)（地址解析協議）

八

一、请看下面一段代码

static int a = 1;
int main(){
int b = 2;
char *c = NULL;
c = (char *)malloc(100 * sizeof(char));
return 0;
}
请问访问a,b,c 3种类型变量的效率从高到低依次是（B）
A. cba
B. abc
C. acb
D. bca

二、下面四种内部排序算法中哪种在最差状况下时间复杂度最高？（B）
A. 快速排序
B. 冒泡排序
C. 堆排序
D. 归并排序

三、Shell中，将command1的输出做为command2的输入应该使用的命令是（D）
A. command1 && command2
B. command1 > command2
C. command1 & command2
D. command1 | command2

四、下面的数据结构中不属于线性结构的是（C）
A. 栈
B. 链表
C. 二叉树
D. 线性表

五、在一个二叉树上，第5层最多能够有的节点数是（C）
A. 2
B. 8
C. 16
D. 32

六、在长度为n的线性表上进行顺序查找，在最糟糕的状况下须要的比较次数是（A）
A. n
B. 2n-1
C. 2n
D. n^2

七、下面那项不是动态语言的特性（B）
A. 在运行时替换一个类
B. 在运行时动态加载lib文件
C. 在运行时修改对象中的方法
D. 在运行时增长对象的方法

八、已知二叉树后序遍历序列是dabec，中序遍历序列是debac，它的前序遍历序列是（A）
A. cedba
B. acbed
C. decab
D. deabc

九、如下多线程对int型变量x的操做，哪一个不须要进行同步：（D）
A. x=y
B. x++
C. ++x
D. x=1

十、多线程中栈与堆是公有的仍是私有的（C）
A. 栈公有, 堆私有
B. 栈公有，堆公有
C. 栈私有, 堆公有
D. 栈私有，堆私有

十一、在Xcode中，须要编译混合Objective-C和C++的源码文件，须要将文件格式的后缀改成（C）
A. .c
B. .cpp
C. .mm
D. .m

十二、Objective-C声明一个类所要用到的编译指令是（A）
A. @interface SomeClass
B. @protocol SomeClass
C. @implementation SomeClass
D. @autorelease SomeClass

1三、使用Xcode建立工程时，支持同时建立的版本管理库是（C）
A. Subversion
B. Mercurial
C. Git
D. Concurrent Versions System

1四、下面那个方法不属于NSObject的内省（Introspection）方法（A）
A. init
B. isKindOfClass
C. responseToSelector
D. isMemberOfClass

1五、使用protocol时，声明一组可选择实现与否的函数，须要在声明的前一行加上：（B）
A. @required
B. @optional
C. @interface
D. @protocol

1六、须要在手动管理内存分配和释放的Xcode项目中引入和编译用ARC风格编写的文件，须要在文件的Compiler Flags上添加参数：（C）
A. -shared
B. -fno-objc-arc
C. -fobjc-arc
D. -dynamic

1七、下面关于Objective-C内存管理的描述错误的是（A）
A. 当使用ARC来管理内存时，代码中不能够出现autorelease
B. autoreleasepool 在 drain 的时候会释放在其中分配的对象
C. 当使用ARC来管理内存时，在线程中大量分配对象而不用autoreleasepool则可能会形成内存泄露
D. 在使用ARC的项目中不能使用NSZone

1八、下面关于#import和#include的描述正确的是（A）
A. #import 是 #include 的替代指令，防止重复引用
B. #import 和 #include 不能够混合使用
C. #import 只用于引用 Objective-C的文件， #include 只用于引用C和C++的文件
D. #import 和 #include 的使用效果彻底相同

1九、下面的代码问题在哪？（B）

@implementation xxx
…
…
– (void) setVar:(int)i {
self.var = i;
}
A. 应该将var synthesize
B. 调用会出现死循环
C. 正常
D. 返回值错误

20、下面那个方法能够比较两个NSString *str1, *str2 的异同（B）
A. if(str1 = str2) xxx ;
B. if([str1 isEqualToString:str2]) xxx ;
C. if(str1 && str2) xxx ;
D. if([str1 length] == [str2 length]) xxx;

2一、下面哪一个不属于对象数据序列化方法（D）
A. JSON
B. Property List
C. XML
D. HTTP

2二、在UIKit中，frame与bounds的区别是（C）
A. frame 是 bounds 的别名
B. frame 是 bounds 的继承类
C. frame 的参考系是父视图坐标，bounds 的参考系是自身的坐标
D. frame 的参考系是自身坐标，bounds 的参考系是父视图的坐标

2三、Objective-C有私有方法吗？有私有变量吗？（C）
A. 有私有方法和私有变量
B. 没有私有方法也没有私有变量
C. 没有私有方法，有私有变量
D. 有私有方法，没有私有变量

2四、下面关于线程管理错误的是（B）
A. GCD所用的开销要比NSThread大
B. 能够在子线程中修改UI元素
C. NSOperationQueue是比NSthread更高层的封装
D. GCD能够根据不一样优先级分配线程

2五、下面代码的做用是让doSomeThing函数每隔1秒被调用1次。请问哪里有问题（A）

NSTimer *myTimer = [NSTimer timerWithTimeInterval:1.0 target:self selector:@selector(doSomeThing:) userInfo:nil repeats:YES];

[myTimer fire]
A. 没有将timer加入runloop
B. doSomeThing缺乏参数
C. 忘记传递数据给userInfo
D. myTimer对象未经过[[myTimer alloc] init]方法初始化

2六、UIViewController在显示过程当中，各个方法的调用顺序是（A）
A. init -> viewDidLoad -> viewDidAppear -> viewDidUnload
B. init -> viewDidAppear -> viewDidLoad -> viewDidUnload
C. init -> viewDidLoad -> viewDidUnload -> viewDidAppear
D. init -> viewDidAppear -> viewDidUnload -> viewDidLoad

2七、使用imageNamed方法建立UIImage对象时，与普通的init方法有什么区别？（C）
A. 没有区别，只是为了方便
B. imageNamed方法只是建立了一个指针，没有分配其余内存
C. imageNamed方法将图片加载到内存中后再也不释放
D. imageNamed方法将使用完图片后当即释放

2八、一个类的delegate（代理）的做用不正确的是（D）
A. delegate中的函数在其余类中实现
B. 主要用于不一样类型的对象之间一对一传递消息
C. 没有指派则不会触发
D. 能够一个对象的delegate指派给多个其余类型的对象

2九、在没有navigationController的状况下，要从一个ViewController切换到另外一个ViewController应该（D）
A. [self.navigationController pushViewController:nextViewController animated:YES];
B. [self.view addSubview:nextViewController.view];
C. [self pushViewController:nextViewController animated:YES];
D. [self presentModalViewController:nextViewController animated:YES];

30、什么是key window？（C）A. App中惟一的那个UIWindow对象B. 能够指定一个key的UIWindowC. 可接收到键盘输入等事件的UIWindowD. 不能够隐藏的那个UIWindow对象