3、请说明一下objective-c中#import 、#include 及@class的区别？#import<>跟#import”"有什么区别?

.#import 是oc导入头文件的关键字，#include是c/c++导入头文件的关键字，#import会自动导入一次，不会重复导入，不会引起交叉编译，@class告诉编译器某个类的声明，当执行是才去查看类的执行文件，当两个类文件有循环依赖关系(A引用B,B引用A)时，需要用@class，
在interface中引用一个类，就用@class，它会把这个类作为一个类型来使用，而在实现这个interface的文件中，如果需要引用这个类的实体变量或者方法之类的，还是需要import这个在@class中声明的类。
＃import<>引用系统文件，它用于对系统自带的头文件的引用，编译器会在系统文件目录下去查找该文件.
.#import"":用户自定义的文件用双引号引用，编译器首先会在用户目录下查找，然后到安装目录中查

.#include <x.h>:它用于对系统自带的头文件的引用，编译器会在系统文件目录下去查找该文件.
.#include "x.h":用户自定义的文件用双引号引用，编译器首先会在用户目录下查找，然后到安装目录中查找，最后在系统文件中查找。
在使用#include的时候要注意处理重复引用（这也是objc中#include与#import的区别）
例如：ClassA 与 ClassB同时引用了ClassC，不做重复引用处理的时候在ClassD中同时引用ClassA，ClassB编译会提示对ClassC重复引用的错误.
我们可以:#ifndef _CLASSC_H
#define _CLASSC_H
#include "ClassC"
#endif
这样处理在编译时就不会有重复引用的错误出现（在objc中#import解决了这个问题，这是它们的区别）

.#import--避免重复引用
#import 大部分功能和#include是一样的，但是他处理了重复引用的问题，我们在引用文件的时候不用再去自己进行重复引用处理.
@class--避免循环引用
主要是用于声明一个类，告诉编译器它后面的名字是一个类的名字，而这个类的定义实现是暂时不用知道的，后面会告诉你.也是因为在@class仅仅只是声明一个类，所以在后面的实现文件里面是需要去#import这个类，这时候才包含了这个被引用的类的所有信息。

.#include与#import在引用一个类的时候会包含这个类的所有信息包括变量方法等，但是这样做会对编译效率造成影响.比如有100个类都#import了ClassA，那么在编译的时候这100个类都会去对ClassA处理.又比如A被B引用，B被C引用，C被D引用.....此时如果A被修改，那么后面的B，C，D.....都需要重新进行编译.还有一个用法会引起编译错误的就是在ClassA中#import ClassB 在ClassB中#import ClassA那么在编译的时候也会出现未知错误。所以一般来说，在interface中引用一个类，就用@class，它会把这个类作为一个类型来使用，而在实现这个interface的文件中，如果需要引用这个类的实体变量或者方法之类的，还是需要import这个在@class中声明的类。@class只是简单的一个声明告编译器有这个类不让其报错，那么.m中要用到引入的类的方法和属性时，不还是要#import头文件一次，是的这个是对的，但编译器编译的时候只编译头文件的，所以你的.m中用#import与编译时间没太大关系

什么时候该用#import进行声明
(1)一般如果有继承关系的用#import，如Ｂ是Ａ的子类那么在Ｂ中声明Ａ时用#import
(2) 另外就是如果有循环依赖关系，如：A->B,B->A这样相互依赖时，如果在两个文件的头文件中用#import分别声明对方，那么就会出现头文件循环利用的错误，这时在头文件中用@class声明就不会出错
(3)还有就是自定义代理的时候，如果在头文件中想声明代理的话如@interface SecondViewController:UIViewController时应用#import不然的话会出错误，注意ＸＸＸＸDelegate是自定义的

1. 一般来说，导入objective c的头文件时用#import，包含c/c++头文件时用#include。
2. .#import 确定一个文件只能被导入一次，这使你在递归包含中不会出现问题。<标记>
   所以，#import比起#include的好处就是不会引起交叉编译。

.#import && #class:

1. import会包含这个类的所有信息，包括实体变量和方法（.h文件中），而@class只是告诉编译器，其后面声明的名称是类的名称，至于这些类是如何定义的，后面会再告诉你。
2. 在头文件中， 一般只需要知道被引用的类的名称就可以了。 不需要知道其内部的实体变量和方法，所以在头文件中一般使用@class来声明这个名称是类的名称。 而在实现类里面，因为会用到这个引用类的内部的实体变量和方法，所以需要使用#import来包含这个被引用类的头文件。
   备注：#import 就是把被引用类的头文件走一遍，即把.h文件里的变量和方法包含进来一次，且仅一次，而@class不用，所以后者编译效率更高。
3. 在编译效率方面考虑，如果你有100个头文件都#import了同一个头文件，或者这些文件是依次引用的，如A–>B, B–>C, C–>D这样的引用关系。当最开始的那个头文件有变化的话，后面所有引用它的类都需要重新编译，如果你的类有很多的话，这将耗费大量的时间。而是用@class则不会。
4. 如果有循环依赖关系，如:A–>B, B–>A这样的相互依赖关系，如果使用#import来相互包含，那么就会出现编译错误，如果使用@class在两个类的头文件中相互声明，则不会有编译错误出现。
   备注：实践证明，A,B相互#import不会出现编译错误。因为<标记>处已经说明#import时文件只被导入一次，所以此条不成立。
   总结：
   1.如果不是c/c++，尽量用#import。
   2.能在实现文件中#import，就不在头文件中#import。
   3.能在头文件中@class+实现文件中#import，就不在头文件中#import。

（1）#import指令是Object-C针对#include的改进版本，#import确保引用的文件只会被引用一次，这样就不会陷入递归包含的问题中。
（2）#import与@class二者的区别在于：
　　#import会链入该头文件的全部信息，包括实体变量和方法等；而@class只是告诉编译器，其后面声明的名称是类的名称，至于这些类是如何定义的，暂时不用考虑。在头文件中， 一般只需要知道被引用的类的名称就可以了。

1、Object_C的类可以多重继承么？可以实现多个接口么？Category是什么？重写一个雷的方式用继承好还是用分类好？为什么？

Object-c的类不可以多重继承；可以实现多个接口，通过实现多个接口可以完成C++的多重继承；
Category是类别，一般情况用分类好，用Category去重写类的方法，仅对本Category有效，不会影响到其他类与原有类的关系。

3、属性readwrite，readonly，assign，retain，copy，nonatomic各是什么作用，在哪种情况下使用？

readwrite 是可读可写特性；需要生成getter方法和setter方法时（补充：默认属性，将生成不带额外参数的getter和setter方法（setter方法只有一个参数））
readonly 是只读特性 只会生成getter方法 不会生成setter方法 ;不希望属性在类外改变
assign 是赋值特性，setter方法将传入参数赋值给实例变量；仅设置变量时；
retain 表示持有特性，setter方法将传入参数先保留，再赋值，传入参数的retaincount会+1;
copy 表示拷贝特性，setter方法将传入对象复制一份；需要完全一份新的变量时。
nonatomic 非原子操作，决定编译器生成的setter getter是否是原子操作，
atomic表示多线程安全，一般使用nonatomic

最全的iOS面试题及答案

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 各是什么作用，在那种情况下用?

1. readwrite 是可读可写特性;需要生成getter方法和setter方法时。
2. readonly 是只读特性 只会生成getter方法 不会生成setter方法 ;不希望属性在类外改变。
3. assign 是赋值特性，setter方法将传入参数赋值给实例变量;仅设置变量时;
4. retain 表示持有特性，setter方法将传入参数先保留，再赋值，传入参数的retaincount会+1;
5. copy 表示赋值特性，setter方法将传入对象复制一份;需要完全一份新的变量时。
6. nonatomic 非原子操作，决定编译器生成的setter getter是否是原子操作，atomic表示多线程安全，一般使用nonatomic

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

- (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(自动内存计数)、手动内存计数、内存池。

1. (Garbage Collection)自动内存计数：这种方式和java类似，在你的程序的执行过程中。始终有一个高人在背后准确地帮你收拾垃圾，你不用考虑它什么时候开始工作，怎样工作。你只需要明白，我申请了一段内存空间，当我不再使用从而这段内存成为垃圾的时候，我就彻底的把它忘记掉，反正那个高人会帮我收拾垃圾。遗憾的是，那个高人需要消耗一定的资源，在携带设备里面，资源是紧俏商品所以iPhone不支持这个功能。所以“Garbage Collection”不是本入门指南的范围，对“Garbage Collection”内部机制感兴趣的同学可以参考一些其他的资料，不过说老实话“Garbage Collection”不大适合适初学者研究。
   解决: 通过alloc – initial方式创建的, 创建后引用计数+1, 此后每retain一次引用计数+1, 那么在程序中做相应次数的release就好了.
2. (Reference Counted)手动内存计数：就是说，从一段内存被申请之后，就存在一个变量用于保存这段内存被使用的次数，我们暂时把它称为计数器，当计数器变为0的时候，那么就是释放这段内存的时候。比如说，当在程序A里面一段内存被成功申请完成之后，那么这个计数器就从0变成1(我们把这个过程叫做alloc)，然后程序B也需要使用这个内存，那么计数器就从1变成了2(我们把这个过程叫做retain)。紧接着程序A不再需要这段内存了，那么程序A就把这个计数器减1(我们把这个过程叫做release);程序B也不再需要这段内存的时候，那么也把计数器减1(这个过程还是release)。当系统(也就是Foundation)发现这个计数器变成了0，那么就会调用内存回收程序把这段内存回收(我们把这个过程叫做dealloc)。顺便提一句，如果没有Foundation，那么维护计数器，释放内存等等工作需要你手工来完成。
   解决:一般是由类的静态方法创建的, 函数名中不会出现alloc或init字样, 如[NSString string]和[NSArray arrayWithObject:], 创建后引用计数+0, 在函数出栈后释放, 即相当于一个栈上的局部变量. 当然也可以通过retain延长对象的生存期.
3. (NSAutoRealeasePool)内存池：可以通过创建和释放内存池控制内存申请和回收的时机.
   解决:是由autorelease加入系统内存池, 内存池是可以嵌套的, 每个内存池都需要有一个创建释放对, 就像main函数中写的一样. 使用也很简单, 比如[[[NSString alloc]initialWithFormat:@”Hey you!”] autorelease], 即将一个NSString对象加入到最内层的系统内存池, 当我们释放这个内存池时, 其中的对象都会被释放.

9.原子(atomic)跟非原子(non-atomic)属性有什么区别?

1. atomic提供多线程安全。是防止在写未完成的时候被另外一个线程读取，造成数据错误；
2. non-atomic:在自己管理内存的环境中，解析的访问器保留并自动释放返回的值，如果指定了 nonatomic ，那么访问器只是简单地返回这个值。

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

=======================================================
NSMutableArray* ary = [[NSMutableArray array] retain];
NSString *str = [NSString stringWithFormat:@"test"];
[str retain];
[ary addObject:str];
NSLog(@"%@%lu",str,(unsigned long)[str retainCount]);
[str retain];
[str release];
[str release];
NSLog(@"%@%lu",str,(unsigned long)[str retainCount]);
[ary removeAllObjects];
NSLog(@"%@%lu",str,(unsigned long)[str retainCount]);
　　=======================================================
　　str的retainCount创建+1，retain+1，加入数组自动+1 3
　　retain+1，release-1，release-1 2
　　数组删除所有对象，所有数组内的对象自动-1 1

11. 内存管理的几条原则时什么?按照默认法则.那些关键字生成的对象需要手动释放?在和property结合的时候怎样有效的避免内存泄露?

谁申请，谁释放
遵循Cocoa Touch的使用原则;
内存管理主要要避免“过早释放”和“内存泄漏”，对于“过早释放”需要注意@property设置特性时，一定要用对特性关键字，对于“内存泄漏”，一定要申请了要负责释放，要细心。
关键字alloc 或new 生成的对象需要手动释放;
设置正确的property属性，对于retain需要在合适的地方释放，

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

Profile-> Instruments ->Time Profiler

13. Object C中创建线程的方法是什么?如果在主线程中执行代码，方法是什么?如果想延时执行代码、方法又是什么?

线程创建有三种方法：使用NSThread创建、使用GCD的dispatch、使用子类化的NSOperation,然后将其加入NSOperationQueue;在主线程执行代码，方法是performSelectorOnMainThread，如果想延时执行代码可以用performSelector:onThread:withObject:waitUntilDone:

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

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

15 浅复制和深复制的区别?

答案：浅层复制：只复制指向对象的指针，而不复制引用对象本身。
深层复制：复制引用对象本身。
意思就是说我有个A对象，复制一份后得到A_copy对象后，对于浅复制来说，A和A_copy指向的是同一个内存资源，复制的只不过是是一个指针，对象本身资源还是只有一份，那如果我们对A_copy执行了修改操作,那么发现A引用的对象同样被修改，这其实违背了我们复制拷贝的一个思想。深复制就好理解了,内存中存在了两份独立对象本身。
用网上一哥们通俗的话将就是：
浅复制好比你和你的影子，你完蛋，你的影子也完蛋
深复制好比你和你的克隆人，你完蛋，你的克隆人还活着。

16. 类别的作用?继承和类别在实现中有何区别?

答案：category 可以在不获悉，不改变原来代码的情况下往里面添加新的方法，只能添加，不能删除修改。并且如果类别和原来类中的方法产生名称冲突，则类别将覆盖原来的方法，因为类别具有更高的优先级。
　　类别主要有3个作用：
　　(1)将类的实现分散到多个不同文件或多个不同框架中。
　　(2)创建对私有方法的前向引用。
　　(3)向对象添加非正式协议。
　　继承可以增加，修改或者删除方法，并且可以增加属性。

17. 类别和类扩展的区别。

答案：category和extensions的不同在于extensions可以添加属性。另外extensions添加的方法是必须要实现的。extensions可以认为是一个私有的Category。

18. oc中的协议和java中的接口概念有何不同?

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

19. 什么是KVO和KVC?

答案：kvc:键 – 值编码，是一种间接访问对象的属性使用字符串来标识属性，而不是通过调用存取方法，直接或通过实例变量访问的机制。很多情况下可以简化程序代码。apple文档其实给了一个很好的例子。
kvo:键值观察机制，他提供了观察某一属性变化的方法，极大的简化了代码。
具体用看到嗯哼用到过的一个地方是对于按钮点击变化状态的的监控。
比如我自定义的一个button
[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就行了，可以按照kvc查找的逻辑理解，就说的过去了。

20. 代理的作用?

答案：代理的目的是改变或传递控制链。允许一个类在某些特定时刻通知到其他类，而不需要获取到那些类的指针。可以减少框架复杂度。
另外一点，代理可以理解为java中的回调监听机制的一种类似。

21. oc中可修改和不可以修改类型。

答案：可修改不可修改的集合类。这个我个人简单理解就是可动态添加修改和不可动态添加修改一样。
　　比如NSArray和NSMutableArray。前者在初始化后的内存控件就是固定不可变的，后者可以添加等，可以动态申请新的内存空间。

22. 我们说的oc是动态运行时语言是什么意思?

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

23. 通知和协议的不同之处?

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

3.代理和通知的区别

答：代理通常用于一对一的关系，通知可以是一对一或一对多或一对无的关系。代理的receive可以把结果返回给sender，通知的sender只负责把消息发送出去不需要返回结果。

24. 是推送消息?

答案：太简单，不作答~~~~~~~~~~
　　这是cocoa上的答案。
　　其实到不是说太简单，只是太泛泛的一个概念的东西。就好比说，什么是人。
　　推送通知更是一种技术。
　　简单点就是客户端获取资源的一种手段。
　　普通情况下，都是客户端主动的pull。
　　推送则是服务器端主动push。 测试push的实现可以查看该博文。

25. 关于多态性

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

26. 对于单例的理解

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

27. 说说响应链

答案： 事件响应链。包括点击事件，画面刷新事件等。在视图栈内从上至下，或者从下之上传播。
　　可以说点事件的分发，传递以及处理。具体可以去看下touch事件这块。因为问的太抽象化了
　　严重怀疑题目出到越后面就越笼统。
　　可以从责任链模式，来讲通过事件响应链处理，其拥有的扩展性

28. frame和bounds有什么不同?

答案:frame指的是：该view在父view坐标系统中的位置和大小。(参照点是父亲的坐标系统)
　　bounds指的是：该view在本身坐标系统中 的位置和大小。(参照点是本身坐标系统)

29. 方法和选择器有何不同?

答案：selector是一个方法的名字，method是一个组合体，包含了名字和实现.

2 浅谈ios开发中几种基本的设计模式

答：
1）模型视图控制器(MVC)。
控制器负责行为，模型提供数据源，视图显示UI。模型和视图之间尽量不要直接打交道，他们之间的交互应该通过控制器来进行，控制器充当着桥梁的作用。这样设计的目的是使不同功能的类之间尽量解耦，以利于程序的扩展。

2）代理模式
委托代理（degegate），顾名思义，把某个对象要做的事情委托给别的对象去做。那么别的对象就是这个对象的代理，代替它来打理要做的事。反映到程序中，首先要明确一个对象的委托方是哪个对象，委托所做的内容是什么。这里所做的内容是靠协议中的方法来实现，方法分两种：必需实现(@required)的方法和根据情况选择实现(@optional)的方法。
举个例子：你是房屋租赁中介，某个房东和你签订协议，请你替他把房子出租出去。这时，你就是房东的代理，你必须实现的方法是把屋子出租出去，选择实现的方法是装修、添置家具、打隔断等（依据协议而定）。

3）通知模式
通知模式是观察者模式的一种。a对象在通知中心注册了观察者之后，b对象发出通知广播，a对象收到通知后就知道去做具体的事。观察者可以是一个或多个，也可以没有。举个例子：微博切换帐号后会发出一个通知，让多个界面重新刷新数据。

4）KVO模式
Key-Value-Observer模式也是观察者模式的一种。KVO的机制为：当指定的被观察对象的属性被修改的时候，KVO都会自动的去通知相应的观察者。举个例子，在控制器里通过addObserver:forKeyPath:options:context:注册一个数据源观察者，当数据源里的数据发生变化时，通过willChangeValueForKey:和didChangeValueForKey:这一对方法发出广播，控制器收到广播后就可以利用新的数据来刷新界面。

5）单例模式
通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。
单例模式有时也是出于现实逻辑的考虑，比如，一个学校只能有一个校长，校长对象应该就是一个单例对象。虽然从程序的角度你可以初始化多个校长，但这并不符合客观现实。

3.类变量的@protected ,@private,@public,@package声明各有什么含义？

答：变量的作用域不同。
@protected 该类和所有子类中 的方法可以直接访问这样的变量，这是默认的，
@private 该类中的方法可以访问这样的变量，子类不可以。
@public 除了自己和子类方法外，也可以被其他类或者其他模块中的方法访问
@package

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

31. NSOperation queue?

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

32. 什么是延迟加载?

答案：懒汉模式，只在用到的时候才去初始化。
也可以理解成延时加载。
我觉得最好也最简单的一个列子就是tableView中图片的加载显示了。
一个延时载，避免内存过高，一个异步加载，避免线程堵塞。

33. 是否在一个视图控制器中嵌入两个tableview控制器?

答案：一个视图控制只提供了一个View视图，理论上一个tableViewController也不能放吧，只能说可以嵌入一个tableview视图。当然，题目本身也有歧义，如果不是我们定性思维认为的UIViewController，而是宏观的表示视图控制者，那我们倒是可以把其看成一个视图控制者，它可以控制多个视图控制器，比如TabbarController那样的感觉。

34. 一个tableView是否可以关联两个不同的数据源?你会怎么处理?

答案：首先我们从代码来看，数据源如何关联上的，其实是在数据源关联的代理方法里实现的。
　　因此我们并不关心如何去关联他，他怎么关联上，方法只是让我返回根据自己的需要去设置如相关的数据源。
　　因此，我觉得可以设置多个数据源啊，但是有个问题是，你这是想干嘛呢?想让列表如何显示，不同的数据源分区块显示?

35. 什么时候使用NSMutableArray，什么时候使用NSArray?

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

36. 给出委托方法的实例，并且说出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;

37. 在应用中可以创建多少autorelease对象，是否有限制?

答案：无

38. 如果我们不创建内存池，是否有内存池提供给我们?

答案:界面线程维护着自己的内存池，用户自己创建的数据线程，则需要创建该线程的内存池

39. 什么时候需要在程序中创建内存池?

答案：用户自己创建的数据线程，则需要创建该线程的内存池

40. 类NSObject的那些方法经常被使用?

答案：NSObject是Objetive-C的基类，其由NSObject类及一系列协议构成。其中类方法alloc、class、 description，对象方法init、dealloc、– performSelector:withObject:afterDelay:等经常被使用

41. 什么是简便构造方法?

答案：简便构造方法一般由CocoaTouch框架提供，如：
NSNumber的
+numberWithBool:
+numberWithChar:
+numberWithDouble:
+numberWithFloat:
+numberWithInt:
Foundation下大部分类均有简便构造方法，我们可以通过简便构造方法，获得系统给我们创建好的对象，并且不需要手动释放。

42. 如何使用Xcode设计通用应用?

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

43. UIView的动画效果有那些?

答案：有很多，如
UIViewAnimationOptionCurveEaseInOut，
UIViewAnimationOptionCurveEaseIn，
UIViewAnimationOptionCurveEaseOut，
UIViewAnimationOptionTransitionFlipFromLeft，
UIViewAnimationOptionTransitionFlipFromRight，
UIViewAnimationOptionTransitionCurlUp，
UIViewAnimationOptionTransitionCurlDown。

44. 在iPhone应用中如何保存数据?

答案：有以下几种保存机制：
　　1.通过web服务，保存在服务器上
　　2.通过NSCoder固化机制，将对象保存在文件中
　　3.通过SQlite或CoreData保存在文件数据库中

45. 什么是coredata?

答案：coredata是苹果提供一套数据保存框架，其基于SQlite

46. 什么是NSManagedObject模型?

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

47. 什么是NSManagedobjectContext?

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

48. 什么是谓词?

答案：谓词是通过NSPredicate，是通过给定的逻辑条件作为约束条件，完成对数据的筛选。
predicate = [NSPredicate predicateWithFormat:@"customerID == %d",n];
a = [customers filteredArrayUsingPredicate:predicate];

49. 和coredata一起有哪几种持久化存储机制?

答案：存入到文件、 存入到NSUserDefaults(系统plist文件中)、存入到Sqlite文件数据库

50. 谈谈对Block 的理解?并写出一个使用Block执行UIVew动画?

答案：Block是可以获取其他函数局部变量的匿名函数，其不但方便开发，并且可以大幅提高应用的执行效率(多核心CPU可直接处理Block指令)
[UIView transitionWithView:self.view
duration:0.2
options:UIViewAnimationOptionTransitionFlipFromLeft
animations:^{ [[blueViewController view] removeFromSuperview]; [[self view] insertSubview:yellowViewController.view atIndex:0]; }
completion:NULL];

51. 写出上面代码的Block的定义。

答案：
　　typedef void(^animations) (void);
　　typedef void(^completion) (BOOL finished);

52. 试着使用+ 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);操作的函数执行部分

答案：无
网络部分

53. 做过的项目是否涉及网络访问功能，使用什么对象完成网络功能?

答案：ASIHTTPRequest与NSURLConnection

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

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

55. 多线程是什么

多线程是个复杂的概念，按字面意思是同步完成多项任务，提高了资源的使用效率，从硬件、操作系统、应用软件不同的角度去看，多线程被赋予不同的内涵，对于硬件，现在市面上多数的CPU都是多核的，多核的CPU运算多线程更为出色;从操作系统角度，是多任务，现在用的主流操作系统都是多任务的，可以一边听歌、一边写博客;对于应用来说，多线程可以让应用有更快的回应，可以在网络下载时，同时响应用户的触摸操作。在iOS应用中，对多线程最初的理解，就是并发，它的含义是原来先做烧水，再摘菜，再炒菜的工作，会变成烧水的同时去摘菜，最后去炒菜。

56. iOS 中的多线程

iOS中的多线程，是Cocoa框架下的多线程，通过Cocoa的封装，可以让我们更为方便的使用线程，做过C++的同学可能会对线程有更多的理解，比如线程的创立，信号量、共享变量有认识，Cocoa框架下会方便很多，它对线程做了封装，有些封装，可以让我们创建的对象，本身便拥有线程，也就是线程的对象化抽象，从而减少我们的工程，提供程序的健壮性。
GCD是(Grand Central Dispatch)的缩写 ：
从系统级别提供的一个易用地多线程类库，具有运行时的特点，能充分利用多核心硬件。GCD的API接口为C语言的函数，函数参数中多数有Block，关于Block的使用参看这里，为我们提供强大的“接口”，对于GCD的使用参见本文
NSOperation与Queue
NSOperation是一个抽象类，它封装了线程的细节实现，我们可以通过子类化该对象，加上NSQueue来同面向对象的思维，管理多线程程序。具体可参看这里：一个基于NSOperation的多线程网络访问的项目。
NSThread
NSThread是一个控制线程执行的对象，它不如NSOperation抽象，通过它我们可以方便的得到一个线程，并控制它。但NSThread的线程之间的并发控制，是需要我们自己来控制的，可以通过NSCondition实现。
参看 iOS多线程编程之NSThread的使用
其他多线程
在Cocoa的框架下，通知、Timer和异步函数等都有使用多线程，(待补充).

57. 在项目什么时候选择使用GCD，什么时候选择NSOperation?

项目中使用NSOperation的优点是NSOperation是对线程的高度抽象，在项目中使用它，会使项目的程序结构更好，子类化NSOperation的设计思路，是具有面向对象的优点(复用、封装)，使得实现是多线程支持，而接口简单，建议在复杂项目中使用。
项目中使用GCD的优点是GCD本身非常简单、易用，对于不复杂的多线程操作，会节省代码量，而Block参数的使用，会是代码更为易读，建议在简单项目中使用。

58. 什么是block

对于闭包(block),有很多定义，其中闭包就是能够读取其它函数内部变量的函数，这个定义即接近本质又较好理解。对于刚接触Block的同学，会觉得有些绕，因为我们习惯写这样的程序main(){ funA();} funA(){funB();} funB(){…..}; 就是函数main调用函数A，函数A调用函数B… 函数们依次顺序执行，但现实中不全是这样的，例如项目经理M，手下有3个程序员A、B、C，当他给程序员A安排实现功能F1时，他并不等着A完成之后，再去安排B去实现F2，而是安排给A功能F1，B功能F2，C功能F3，然后可能去写技术文档，而当A遇到问题时，他会来找项目经理M，当B做完时，会通知M，这就是一个异步执行的例子。在这种情形下，Block便可大显身手，因为在项目经理M，给A安排工作时，同时会告诉A若果遇到困难，如何能找到他报告问题(例如打他手机号)，这就是项目经理M给A的一个回调接口，要回掉的操作，比如接到电话，百度查询后，返回网页内容给A，这就是一个Block，在M交待工作时，已经定义好，并且取得了F1的任务号(局部变量)，却是在当A遇到问题时，才调用执行，跨函数在项目经理M查询百度，获得结果后回调该block。

59. block 实现原理

Objective-C是对C语言的扩展，block的实现是基于指针和函数指针。
从计算语言的发展，最早的goto，高级语言的指针，到面向对象语言的block，从机器的思维，一步步接近人的思维，以方便开发人员更为高效、直接的描述出现实的逻辑(需求)。
下面是两篇很好的介绍block实现的博文
iOS中block实现的探究
谈Objective-C Block的实现

3 block的使用

使用实例
cocoaTouch框架下动画效果的Block的调用
使用typed声明block
typedef void(^didFinishBlock) (NSObject *ob);
这就声明了一个didFinishBlock类型的block，
然后便可用
@property (nonatomic,copy) didFinishBlock finishBlock;
声明一个blokc对象，注意对象属性设置为copy，接到block 参数时，便会自动复制一份。
__block是一种特殊类型，
使用该关键字声明的局部变量，可以被block所改变，并且其在原函数中的值会被改变。

4 常见系列面试题

面试时，面试官会先问一些，是否了解block，是否使用过block，这些问题相当于开场白，往往是下面一系列问题的开始，所以一定要如实根据自己的情况回答。
　　1 使用block和使用delegate完成委托模式有什么优点?
　　首先要了解什么是委托模式，委托模式在iOS中大量应用，其在设计模式中是适配器模式中的对象适配器，Objective-C中使用id类型指向一切对象，使委托模式更为简洁。了解委托模式的细节：
　　iOS设计模式—-委托模式
　　使用block实现委托模式，其优点是回调的block代码块定义在委托对象函数内部，使代码更为紧凑;
　　适配对象不再需要实现具体某个protocol，代码更为简洁。
　　2 多线程与block
　　GCD与Block
　　使用 dispatch_async 系列方法，可以以指定的方式执行block
　　GCD编程实例
　　dispatch_async的完整定义
　　void dispatch_async(dispatch_queue_t queue,dispatch_block_t block);
　　功能：在指定的队列里提交一个异步执行的block，不阻塞当前线程
　　通过queue来控制block执行的线程。主线程执行前文定义的 finishBlock对象
　　dispatch_async(dispatch_get_main_queue(),^(void){finishBlock();});

3.写一个计算A、B中较大值得标准宏MAX

.#define max(a,b) (((a)>(b))?(a):(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++) : (b)) 这个表达式会产生副作用，指针p会作两次++自增操作。除此之外，另一个应该判0分的解答是：#define MIN(A,B) ((A) <= (B) ? (A) : (B));
这个解答在宏定义的后面加“;”，显示编写者对宏的概念模糊不清，只能被无情地判0分并被面试官淘汰。

7.类别的作用是什么？说一下类别和类扩展的区别

一.类别（Category）
类别(Category)是一种可以为现有的类（包括类簇:NSString...，甚至源码无法获得的类）添加新方法的方式无需从现有的类继承子类。类别添加的新方法可以被子类继承。
注：继承(inheritance)无法为一个类簇创建子类。类别不能添加实例变量。

1. 创建类别
1.1 声明类别
类别的声明和类的声明格式相似：
@interface ClassName(CategoryName)
//method declarations
@end//CategoryName

头文件"NSString+Tools.h"：
#import@interface NSString (Tools)
- (NSNumber *) lengthAsNumber;
@end//Tools

1.2 实现类别

实现文件"NSString+Tools.m"：
#import "NSString+Tools.h"
@implementation NSString(Tools)
- (NSNumber *) lengthAsNumber {
    unsigned int length = [self length];
    return [NSNumber numberWithUnsignedInt: length];
}
@end//Tools

2. 类别的作用
类别有以下5个主要作用：
①为现有的类添加新方法；
②将类的实现分散到多个不同文件或多个不同框架中(把一个大的类按功能划分成几块,便于维护)；
③创建对私有方法的前向应用；
④使用category的非正式协议(informal protocol)来实现委托(delegation);
⑤通过替换现有类中的方法，修正现有类(没有源码文件的情况下)的功能或错误。

2.1 把类按功能划分成几块
UIKIT_CLASS_AVAILABLE(2_0) @interface UIView : UIResponder{
    ................................
}
.................................
@end//UIView


@interface UIView(UIViewGeometry)
.................
@end//UIViewGeometry


@interface UIView(UIViewHierarchy)
.................
@end//UIViewHierarchy


@interface UIView(UIViewRendering)
................
@end//UIViewRendering


@interface UIView(UIViewAnimation)
...............
@end//UIViewAnimation


@interface UIView(UIViewAnimationWithBlocks)
........................
@end//UIViewAnimationWithBlocks

2.2 委托和类别
委托是类别的一种应用：被发送给委托对象的方法可以声明为一个NSObject的类别。创建NSObject的类别称为“创建一个非正式协议”。非正式协议只是一种表达方式，它表示“这里有一些你可能希望实现的方法，当然你也可以不实现这些方法”。示例NSNetService委托方法的部分声明如下：


@interface NSObject(NSNetServiceBrowserDelegateMethods)


- (void)netServiceBrowserWillSearch: (NSNetServiceBrowser*) browser;


- (void)netServiceBrowser: (NSNetServiceBrowser*) aNetServiceBrowser
           didFindService: (NSNetService *) service
               moreComing: (BOOL) moreComing;


- (void)netServiceBrowserDidStopSearch: (NSNetServiceBrowser*) browser;


- (void)netServiceBrowser: (NSNetServiceBrowser*) aNetServiceBrowser
         didRemoveService: (NSNetService *) service
               moreComing: (BOOL) moreComing;
@end//NSNetServiceBrowserDelegateMethods

2.2.1 如何知道委托对象能否处理发送给它的消息（响应选择器）
NSNetServiceBrowser首先检查委托对象，通过NSObject类的respondsToSelector:的方法询问其能否响应该选择器。如果委托对象能响应，则NSNetServiceBrowser给委托对象发送消息，反正则不发。
选择器只是一个方法的名称，它以Object-C运行时使用的特殊方式编码，以快速执行查询。使用@selector(方法名称)预编译指令指定选择器。示例：Car类的setEngine:方法的选择器是 @selector(setEngine:)
Car类的setTire: atIndex:方法的选择器是  @selector(setTire: atIndex:)
Car *car = [[Car alloc] init];
if ([car respondsToSelector: @selector(setEngine:)]) {
    return YES;
}

3. 类别的局限性
①无法向现有的类中添加新的实例变量(类别没有位置容纳实例变量)；
②方法名称冲突，即类别中的新方法的名称与现有类中方法名称重名，类别具有更高的优先级，类别中的方法将完全取代现有类中的方法(再也无法访问现有类中的同名方法)

二、类扩展 （Class Extension也有人称为匿名分类）
作用：
. 能为某个类附加额外的属性，成员变量，方法声明
. 一般的类扩展写到.m文件中
. 一般的私有属性写到类扩展

使用格式：
@interface Mitchell ()
// 属性
// 方法
@end

类扩展与分类的区别
* 分类的小括号中必须有名字
@interface 类名（分类名字）
/*方法声明*/
@end
@implementation 类名（分类名字）
/*方法实现*/
@end
* 分类只能扩充方法，不能扩展属性和成员变量（如果包含成员变量会直接报错）。
* 如果分类中声明了一个属性，那么分类只会生成这个属性的set、get方法声明，也就是不会有实现。
* 举例说明：如果我们分别在，类扩展与分类中添加了两个属性，
// 类别
@interface Mitchell(Mit)
@property (nonatomic, copy) NSString *textOne;
@end

// 类扩展
@interface Mitchell ()
@property (nonatomic, copy) NSString *textTwo;
@end

接下来在初始化方法中分别赋值
- (instancetype)init {
    if(self = [super init]) {
        self.textTwo = @"bb";
        NSLog(@"%@",self.textTwo);
        self.textOne = @"aa";
        NSLog(@"%@",self.textOne);
    }
    return self;
}

大家会看到在为在分类中所声明的属性textOne赋值的时候，崩溃了，那么我们来查看一下崩溃的原因：
(lldb)po self.textOne
error:property 'textOne' not fount on object of type 'Mitchell *'
意思是说，我们所创建的对象中并没有textOne这个属性。也就是说虽然我们再类别中声明属性不会报错，但是@property并没有自动为我们设置的属性生成set、get方法。
* 再说一下我们为什么不能包含类的 .m文件，因为这样会重复包含另一个类的实现文件。
======================================================================
分类category：即使在你不知道一个类的源码情况下，向这个类添加扩展的方法，并且分类的实现是和其他文件分开的。
#import "Man+SuperMan.h"
@implementation Man （SuperMan）//括号里代表的是分类category的名字
-(void)fly {
NSLog(@"超人起飞了");
}
分类在此的意思是对于Man这个类，在此处添加的方法时额外的，而不是新开的一个类，你不可以在分类的实现文件中为这个类添加额外的成员变量，而在分类文件中，可以通过关键字self去调用原类Man的方法，也可以访问原类的成员变量即使是私有的。而当分类中的方法和原类中的方法同名时，调用时，调用的是分类的方法，相当于分类的方法覆盖了原类的方法。这又提醒我们，命名方法的时候，一定不要与原类的方法重名。
类扩展（extension）：
1.写法上与category有些许区别，不需要写分类名，也就是我们所说匿名类；
2.类扩展的声明必须在@implementation中实现，也就是说，没有@implementation的类，例如：framework class是不能使用extension的；
3.extension可以为原类提供新的方法的同时同样是可以为原有的类添加成员变量，这也就是类扩展比分类好的地方，早在xcode4之后，就已经建议在自定义类的.m文件中使用类扩展，这样能够很好的保证代码的良好的封装性，进一步避免私有接口的外露。
4.类扩展新增的方法只作用于原类，而不会作用于原类中的子类。