Objective－C

 

Objective-C语言有C++ Java等面向对象的特点。Objective-C的优点是它是动态的。动态能力有三种：

动态类-运行时确定类的对象
动态绑定-运行时确定要调用的方法

动态加载--运行时为程序加载新的模块

运行时决定对象类型，id类型

id obj ＝ someInstance;

if ([obj isKindOfClass:someclass])

{

  someclass*classInstance = (someclass *)obj

动态绑定基于动态类型，某个实例对象类型被确定后，将某些属性和响应的方法绑定到实例上。该队相对应的属性和响应者消息也被完全确定。

在OC中最常用的是消息传递机制。调用实例的方法，所做的是向该实例对象的指针发送消息，实例在收到消息后，

从自身实现中寻找响应这条消息的方法。

在Cocoa层，我们一般向一个NSObject对象发送 －respondsToSelector活着instanceRespondToSelector，在消息机制被触发前

＋resolveClasssMethod  和＋resolveInstanceMethod将会被调用，此时有机会动态的响雷或者实例添加新方法

 

在Retina设备上加载@2x的图片

 

基本动态特性在常规的Cocoa开发中非常常用，由于Cocoac程序大量的使用Protocol－Delegate中的设计模式，因此大部分delegate指针类型必须是id

以满足运行时delegate的动态转换（Java里这种设计模式被称为Strategy？）

面向对象的三个基本特征是:封装、继承、多态。

封装是面向对象的特征之一,是对象和类概念的主要特性。 封装,也就是把客观事物封装成抽象的类,并且类可以把自己的 数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。隐藏对象的属性和实现细节,仅对外公开接口,提高代 码安全性,封转程度越高,独立性越强,使用越方便。 继承是指这样一种能力:它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。 通过 继承创建的新类称为“子类”或“派生类”。 被继承的类称为“基类”、“父类”或“超类” 多态性:允许你将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子 对象的特性以不同的方式运作。简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针

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

Gategory类别的作用？ 

Objective-C 2.0也是有垃圾回收机制的，但是只能在Mac OS X Leopard10.5 以上的版本使用。

IPhone iOS有没有垃圾回收?autorelease 和垃圾回收制(gc)有什么关系?

没有。autorelease只是延迟释放,gc是每隔一段时间询问程序,看是否有无指针指向的对象,若有,就将它回收。他们 两者没有什么关系。

What is lazy loading?

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

cocoa 中所有的类都是NSObject 的子类，你不用去考虑繁琐的多继承 ,虚基类的概念.ood的多态特性 在 obj-c 中通过委托来实现.

 

ARC

iOS8 新特性

 

 

动态的是:运行时才加载到内存中,

静态:编译时就加载到内存中 静态方法也就是类方法,不需要release

Object-C有私有方法吗？私有变量呢？

objective-c 类里面的方法只有两种, 静态方法和实例方法. －－就是类方法和对象方法,

这似乎就不是完整的面向对象了,按照OO的原则就是一个对象只暴露有用的东西. 如果没有了私有方法的话, 对于一些小范围的代码重用就不那么顺手了. 在类里面声名一个私有方法

@interface Controller : NSObject {

     NSString *something;

}

@interface Controller (private)

- (void)thisIsAPrivateMethod;

Swfit与Objective－C相比

＊从语法上来说，Swift更简单，更简洁

＊开发难度上，Swfit比OC难得多，开源框架比较少，会CocOaTouch开发上手简单，如果之间上手Swfit，遇到问题一查资料都是OC的例子

 

什么是动态识别,动态绑定?延展--程序的编译过程

 

 -[_NSZeroData stringByAppendingString:]: unrecognized selector sent to instance 0x8946440

故可以看出NSData 在运行时的真实类型是_NSZeroData（这里用的NSData alloc init,这里是个空的NSData，所以是ZeroData，不是说所有的）

如果对该实例发送诸如 testObject 

base64EncodedStringWithOptions:NSDataBase64Encoding64CharacterLineLength:这类消息 编译器会直接给出红色错误，无法运行，但其实这个实例是有这个方法的。

这里如果改为 id testObject=[[NSData alloc]init];

那么发送NSString 的方法仍然会崩溃，发送NSData的实例方法则完全正常。并且两种情况编译器都不会再给出警告或错误。 这就是运行时语言的特点

 

什么是安全释放?

[_instance release],_instance = nil;

 

OC中异常exception 怎么捕获?不同的CPU结构上开销怎样?C中又什么类似的方法? 了解一下异常捕获

 

run loop,正如其名称所示,是线程进入和被线程用来响应事件以及调用事件处理函数的地方。需要在代码中使用控制语 句实现run loop的循环,也就是说,需要代码提供while 或者 for循环来驱动run loop。在这个循环中,使用一个 runloop对象[NSRunloop currentRunloop]执行接收消息,调用对应的处理函数。

谈谈对性能优化的看法,如何做? 控制好内存,不用的内存实时释放;冗余代码;用户体验度;耗时操作,开线程进行处理

简述值传递和引用传递的区别? 所谓值传递,就是说仅将对象的值传递给目标对象,就相当于copy;系统将为目标对象重新开辟一个完全相同的内存空间。 所谓引用传递,就是说将对象在内存中的地址传递给目标对象,就相当于使目标对象和原始对象对应同一个内存存储空间。此时,如 果对目标对象进行修改,内存中的数据也会改变。

NSArray和NSMutableArray的区别,多线程操作哪个更安全? NSArray更安全,当同时被访问时,NSArray是不可改变

以.mm为拓展名的文件里,可以包含的代码有哪些? .mm是oc和C++混编类型文件后缀,给编译器识别的。

说说如何进行后台运行程序?

BOOL backgroundSupported = NO;
if ([device respondsToSelector:@selector(isMultitaskingSupported)])

backgroundSupported = device.multitaskingSupported;

 

声明你需要的后台任务Info.plist中添加UIBackgroundModes键值,它包含一个或多个string的值,包括audio:在后台提供声音 播放功能,包括音频流和播放视频时的声音 location:在后台可以保持用户的位置信息 voip:在后台使用VOIP功能 前面的每个value让系统知道你的应用程序应该在适当的时候被唤醒。例如,一个应用程序,开始播放音乐,然后移动到后台仍然需要 执行时间,以填补音频输出缓冲区。添加audio键用来告诉系统框架,需要继续播放音频,并且可以在合适的时间间隔下回调应用程 序;如果应用程序不包括此项,任何音频播放在移到后台后将停止运行。除了添加键值的方法,IOS还提供了两种途径使应用程序在后 台工作:

Task completion—应用程序可以向系统申请额外的时间去完成给定的任务

Local notifications—应用程序可以预先安排时间执行local notifications 传递实现长时间的后台任务:应用程序可以请求在后台 运行以实现特殊的服务。这些应用程序并不连续的运行,但是会被系统框架在合适的时间唤醒,以实现这些服务 91

你了解svn,cvs等版本控制工具么?

目标-动作机制 目标是动作消息的接收者。一个控件,或者更为常见的是它的单元,以插座变量的形式保有其动作消息的目标。

动作是控件发送给目标的消息,或者从目标的角度看,它是目标为了响应动作而实现 的方法。 程序需要某些机制来进行事件和指令的 翻译。这个机制就是目标-动作机制。

   NSMutableString *str1=[NSMutableString stringWithString:@"two day"];

   [str1  release];

   [array1 release];

 

   通俗的讲，多个指针同时指向同一块内存区域，那么这些个指针同时拥有对该内存区的所有权。所有权的瓜分过程，这时候就要用到浅拷贝了。

OC中是所有对象间的交互是如何实现的? 通过指针实现的

objective-c中的类型转换分为哪几类? 可变与不可变之间的转化; 可变与可变之间的转化;不可变与不可变之间

 

编译语言和解释语言的区别 区别:C语言,OC语言属于编译语言;解释语言:也可以理解为脚本文件,不需要编译, 编译型语言写的程序执行之前,需要一个专门的编译过程,把程序编译成为机器语言的文件,比如exe文件,以后要运行的 话就不用重新翻译了,直接使用编译的结果就行了(exe文件),因为翻译只做了一次,运行时不需要翻译,所以编译型语 言的程序执行效率高,但也不能一概而论,部分解释型语言的解释器通过在运行时动态优化代码,甚至能够使解释型语言的 性能超过编译型语言。 解释则不同,解释性语言的程序不需要编译,省了道工序,解释性语言在运行程序的时候才翻译, 比如解释性basic语言,专门有一个解释器能够直接执行basic程序,每个语句都是执行的时候才翻译。这样解释性语言每 执行一次就要翻译一次,效率比较低。解释是一句一句的翻译。

#define SECONDS_PER_YEAR (60 * 60 * 24 * 365ul)

1) #define 语法的基本知识（例如：不能以分号结束，括号的使用，等等）

2)懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有多少 秒而不是计算出实际的值，是更清晰而没有代价的。

3) 意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。

4) 如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。

关键字const什么含义

const意味着”只读”，下面的声明都是什么意思？
const int a;
int const a;
const int *a;
int * const a;
int const * a const;

前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。

结论：
•; 关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果
你曾花很多时间清理其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清
理的。）
•; 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。
•; 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。

欲阻止一个变量被改变，可以使用 const 关键字。在定义该const 变量时，通常需要对它进行初
始化，因为以后就没有机会再去改变它了；
（2）对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为 const，或二者同时指
定为const；
（3）在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；
（4）对于类的成员函数，若指定其为const 类型，则表明其是一个常函数，不能修改类的成员变量；
（5）对于类的成员函数，有时候必须指定其返回值为const 类型，以使得其返回值不为“左值”。

 

一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到

id和void *并非完全一样。在上面的代码中，id是指向struct objc_object的一个指针，这个意思基本上是说，id是一个指向任何一个继承了Object（或者NSObject）类的对象。需要注意的是id是一个指针，所以你在使用id的时候不需要加星号。比如id foo=nil定义了一个nil指针，这个指针指向NSObject的一个任意子类。而id *foo=nil则定义了一个指针，这个指针指向另一个指针，被指向的这个指针指向NSObject的一个子类。

id代表任意对象类型  凡是继承于NSObject的都是对象#import是将一个文件全部内容拷到当前文件;id是一个指针，指向任何一个继承了Object（或者NSObject）类的对象，所以在OC中，任意一个object对象都可以是一个id,id不是类型吗instancetype也是指针,void相当于空指针;

 

 

nil和C语言的NULL相同，在objc/objc.h中定义。nil表示一个Objctive-C对象，这个对象的指针指向空（没有东西就是空）

if (a.b. c)

上面的代码当a、b、c中任何一个为nil时，值为false，这样写完全ok，所以没必要写成下面那样：

if a

if b

if c

 

线程和进程的区别

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

(1)管理方式:对于栈来讲,是由编译器自动管理,无需我们手工控制;对于堆来说,释放工作由程序员控制,容易产生 memory leak。

(2)申请大小:能从栈获得的空间较小,堆是向高地址扩展的数据结构,是不连续的内存区域。堆的大小受限于计算机系统中 有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。

(3)碎片问题:对于堆来讲,频繁的new/delete势必会造成内存空间的不连续,从而造成大量的碎片,使程序效率降低。 对于栈来讲,则不会存在这个问题,因为栈是先进后出的队列,他们是如此的一一对应,以至于永远都不可能有一个内存块 从栈中间弹出

(4)分配方式:堆都是动态分配的,没有静态分配的堆。栈有2种分配方式:静态分配和动态分配。静态分配是编译器完成 的,比如局部变量的分配。动态分配由 alloca函数进行分配,但是栈的动态分配和堆是不同的,他的动态分配是由编译器 进行释放,无需我们手工实现。

(5)分配效率:栈是机器系统提供的数据结构,计算机会在底层对栈提供支持:分配专门的寄存器存放栈的地址,压栈出栈 都有专门的指令执行,这就决定了栈的效率比较高。堆则是C/C++函数库提供的,它的机制是很复杂的。

OC使用了一种叫做引用计数的机制来管理对象,如果对一个对象使用了alloc、 [Mutable]copy,retain,那么你必须使用相应的realease或者autorelease。也可以理解为 自己生成的对象,自己持有。非自己生成的对象,自己也能持有。不在需要自己持有的 对象时释放。非自己持有的对象无法释放。生成并持有对象<alloc,new,copy,mutableCopy 等>,持有对象<retain>,释放对象<release>,废弃对象<dealloc>

这种情况，必须打断循环引用，通过其他规则来维护引用关系。比如，我们常见的delegate往往是assign方式的属性而不是retain方式 的属性，赋值不会增加引用计数，就是为了防止delegation两端产生不必要的循环引用。如果一个UITableViewController对象a通过retain获取了UITableView对象b的所有权，这个UITableView对象b的delegate又是a， 如果这个delegate是retain方式的，那基本上就没有机会释放这两个对象了。自己在设计使用delegate模式时，也要注意这点。

委托的interface:声明一个某协议的属性delagate用assgin属性,原因是,为了避免循环引用。

 

autorelease实际上只是把对release的调用延迟了，对于每一个Autorelease，系统只是把该Object放入了当前的Autoreleasepool中，当该pool被释放时，该pool中的所有Object会被调用Release。对于每一个Runloop， 系统会隐式创建一个Autoreleasepool，这样所有的release pool会构成一个象CallStack一样的一个栈式结构，在每一个Runloop结束时，当前栈顶的Autoreleasepool会被销毁，这样这个pool里的每个Object（就是autorelease的对象）会被release。那什么是一个Runloop呢？ 一个UI事件，Timercall， delegate call， 都会是一个新的Runloop

 

 

readwrite,readonly,assign,retain,copy,nonatomic 、strong、weak属性的作用?并区别

strong(强引用)、 weak(弱引用)?什么情况使用copy,assign,和retain?

 

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

retain 和copy用户对象,copy用于当 a指向一个对象,b也想指向同样的对象的时候,如果用assign,a如果释放,再 调用b会crash,如果用copy 的方式,a和b各自有自己的内存,就可以解决这个问题。retain 会使计数器加1,也可以解 决assign的问题。另外:atomic和nonatomic用来决定编译器生成的getter和setter是否为原子操作。 在多线程环境 下,原子操作是必要的,否则有可能引起错误的结果。

 

为什么很多内置类如UITableViewController的delegate属性都是assign而不是retain的? 会引起循环引用----若是retain,在alloc一次之后,若release一次,会导致内训泄漏,若release两次会导致两个 对象的dealloc嵌套执行,结果就是都没有执行成功,最后崩溃! 所有的引用计数系统,都存在循环应用的问题。例如下面的引用关系:

* 对象a创建并引用到了对象b. * 对象b创建并引用到了对象c. * 对象c创建并引用到了对象b.

 

这时候b和c的引用计数分别是2和1。 当a不再使用b,调用release释放对b的所有权,因为c还引用了b,所以b的引用计数为1,b不会被释放。 b不释放,c的引用计数就是1,c也不会被释放。从此,b和c永远留在内存中。 这种情况,必须打断循环引用,通过其他规则来维护引用关系。我们常见的delegate往往是assign方式的属性而不是 retain方式 的属性,赋值不会增加引用计数,就是为了防止delegation两端产生不必要的循环引用。 如果一个UITableViewController 对象a通过retain获取了UITableView对象b的所有权,这个UITableView对象b的 delegate又是a,如果这个delegate是retain方式的,那基本上就没有机会释放这两个对象了。自己在设计使用 delegate模式时,也要注意这点。

ObjC中,与retain配对使用的方法是dealloc还是release,为什么?需要与alloc配对使用的方法是dealloc还

是release,为什么?

与retain配对使用的方法是release,因为retain使retainCount计数加1,release使retainCount计数减1;与 retain语义相反的是release。 与alloc配对使用的是release,因为:alloc是使retainCount计数加1,,使retainCount计数减1。与alloc语义相反

 

setter方法:
-(void)setName:(NSString*)name
{
{[_name release];
_name=[name retain];
}

}

分别描述内存管理要点、autorelease、release、NSAutoreleasePool?并说明autorelease是什 么时候被release的?简述什么时候由你负责释放对象,什么时候不由你释放?

[NSAutoreleasePool release]

和[NSAutoreleasePool drain]有什么区别?

内存管理要点:

Objective-C 使用引用计数机制(retainCount)来管理内存。内存每被引用一次,该内存的引用计数+1,每被释放一次引 用计数-1。当引用计数 = 0 的时候,调用该对象的 dealloc 方法,来彻底从内存中删除该对象。 alloc,allocWithZone,new(带初始化)时:该对象引用计数 +1;
retain:手动为该对象引用计数 +1;

copy:对象引用计数 +1;
mutableCopy:生成一个新对象,新对象引用计数为 1;
release:手动为该对象引用计数 -1; autorelease:把该对象放入自动释放池,当自动释放池释放时,其内的对象引用计数 -1。
NSAutoreleasePool: NSAutoreleasePool是通过接收对象向它发送的autorelease消息,记录该对象的release消息,当自动释放池被销毁 时,会自动向池中的对象发送release消息。
autorelease 是在自动释放池被销毁,向池中的对象发送release
只能释放自己拥有的对象, 区别是:在引用计数环境下(在不使用ARC情况下),两者基本一样,在GC环境下,release 是一个no-op(无效操 作),所以无论是不是gc都使用drain

 

内存管理 Autorelease、retain、copy、assign的set方法和含义？

1，你初始化(alloc/init)的对象，你需要释放(release)它。例如：

　　NSMutableArray aArray = [[NSArray alloc] init];

　　后，需要

　　[aArray release];

　　2，你retain或copy的，你需要释放它。例如：

　　[aArray retain]

　　后，需要

　　[aArray release];

　　3，被传递(assign)的对象，你需要斟酌的retain和release。例如：

　　obj2 = [[obj1 someMethod] autorelease];

　　对象2接收对象1的一个自动释放的值，或传递一个基本数据类型(NSInteger，NSString)时： 你或希望将对象2进行retain，以防止它在被使用之前就被自动释放掉。但是在retain后，一定要在适当的时候进行释放。

 

　　关于索引计数(Reference Counting)的问题

　　retain值 = 索引计数(ReferenceCounting)

　　NSArray对象会retain(retain值加一)任何数组中的对象。当NSArray被卸载(dealloc)的时候，所有数组中的对象会被执行一次释放(retain值减一)。不仅仅是NSArray，任何收集类(CollectionClasses)都执行类似操作。例如NSDictionary，甚至UINavigationController。

　　Alloc/init建立的对象，索引计数为1。无需将其再次retain。

　　[NSArray array]和[NSDate date]等“方法”建立一个索引计数为1的对象，但是也是一个自动释放对象。所以是本地临时对象，那么无所谓了。如果是打算在全Class中使用的变量(iVar)，则必须retain它。

　　缺省的类方法返回值都被执行了“自动释放”方法。(*如上中的NSArray)

　　在类中的卸载方法“dealloc”中，release所有未被平衡的NS对象。(*所有未被autorelease，而retain值为1的)

 

RunLoop就是一个消息传送机制，用于异步的或线程内部的通信，它提供了一套机制来处理系统的输入源（像 socekts，ports，files，keyboard，mouse，定时器等），你可以把它想象成是一个邮局，在等待信件和传递信件给收件人，每个 NSThread都有属于它自己的RunLoop。

RunLoop可以用来区分交互式App和命令行。命令行通过一些参数运行后，执行完他们的程序，这个程序结束了，就像“Hello world”， 只要打印出“Hello world”，这个程序也就结束了。但是交互式的App就会一直等待用户输入，然后做出反应，然后再等待用户输入，知道某一个触发条件发生，才会退出程 序。

Foundation 框架 中的传递机制 delegation，block 和 target-action

Foundation 框架外的 (KVO 和 通知) KVC KVO

KVO（Key-Value-Observing）键-值-监看

 

KVC(Key-Value-Coding)键-值-编码

 

 

首先介绍两个基本概念：

（1）SEL数据类型：它是编译器运行Objective-C里的方法的环境参数。

（2）IMP数据类型：他其实就是一个 编译器内部实现时候的函数指针。当Objective-C编译器去处理实现一个方法的时候，就会指向一个IMP对象，这个对象是C语言表述的类型（事实上，在Objective-C的编译器处理的时候，基本上都是C语言的）。

 

这下KVC内部的实现就很清楚的清楚了：一个对象在调用setValue的时候，（1）首先根据方法名找到运行方法的时候所需要的环境参数。（2）他会从自己isa指针结合环境参数，找到具体的方法实现的接口。（3）再直接查找得来的具体的方法实现。

在上面所介绍的KVC机制上加上KVO的自动观察消息通知机制就水到渠成了。

当观察者为一个对象的属性进行了注册，被观察对象的isa指针被修改的时候，isa指针就会指向一个中间类，而不是真实的类。所以isa指针其实不需要指向实例对象真实的类。所以我们的程序最好不要依赖于isa指针。在调用类的方法的时候，最好要明确对象实例的类名。

熟悉KVO的朋友都知道，只有当我们调用KVC去访问key值的时候KVO才会起作用。所以肯定确定的是，KVO是基于KVC实现的。其实看了上面我们的分析以后，关系KVO的架构的构思也就水到渠成了。

因为KVC的实现机制，可以很容易看到某个KVC操作的Key，而后也很容易的跟观察者注册表中的Key进行匹对。假如访问的Key是被观察的Key，那么我们在内部就可以很容易的到观察者注册表中去找到观察者对象，而后给他发送消息。

 

 

当通过KVC调用对象时，比如：[self valueForKey:@”someKey”]时，程序会自动试图通过几种不同的方式解析这个调用。首先查找对象是否带有 someKey 这个方法，

如果没找到，会继续查找对象是否带有someKey这个实例变量（iVar），

如果还没有找到，程序会继续试图调用 -(id)valueForUndefinedKey:这个方法。

如果这个方法还是没有被实现的话，程序会抛出一个NSUndefinedKeyException异常错误。

 

字典类其实装载的是键值关系，obc里面，NSObject有个function叫做hash,字典类在装载的时候，都会对每个对象取key值

设计valueForUndefinedKey:方法的主要目的是当你使用-(id)valueForKey方法从对象中请求值时，对象能够在错误发生前，有最后的机会响应这个请求。

 

 

 

代理模式 delegate

委托代理（delegate），顾名思义，把某个对象要做的事情委托给别的对象去做。那么别的对象就是这个对象的代理，代替它来打理要做的事。反映到程序中，首先要明确一个对象的委托方是哪个对象，委托所做的内容是什么。

standardUserDefaults],[UIApplication sharedApplication], [UIScreen mainScreen], [NSFileManager defaultManager]他们都是返回一个单例对象。
2.单例模式的优点：
　　1.实例控制：Singleton 会阻止其他对象实例化其自己的 Singleton 对象的副本，从而确保所有对象都访问唯一实例。
　　2.灵活性：因为类控制了实例化过程，所以类可以更加灵活修改实例化过程
 
IOS中的单例模式
　　在objective-c中要实现一个单例类，至少需要做以下3个步骤：
　　1：定义一个静态变量来保存你类的实例确保在你的类里面保持全局。
2：定义一个静态的dispatch_once_t变量来确保这个初始化存在一次。
3：用GCD来执行block初始化libraryAPI实例。这是单例设计模式的本质。这个初始化不在被调用这个类已经被初始化。并且是线程安全的。

代理:是一个代表或者协调另一个对象的行为机制。在Objective-c实现代理的设计模式。一个类可以定义可选或者必须的方法通过协议。这是一个重要的设计模式。苹果在UIKit类里面用到了很多。 UITableView,UITextView, UITextField, UIWebView, UIAlert, UIActionSheet, UICollectionView, UIPickerView,UIGestureRecognizer, UIScrollView.

完整的单例：
      1、为单例对象实现一个静态实例，并初始化，然后设置成nil，
　　2、实现一个实例构造方法检查上面声明的静态实例是否为nil，如果是则新建并返回一个本类的实例，
　　3、重写allocWithZone方法，用来保证其他人直接使用alloc和init试图获得一个新实力的时候不产生一个新实例，
　　4、适当实现allocWitheZone，copyWithZone，release和autorelease。

观察者：在观察者设计模式里面，一个对象通知其他的对象一些状态的改变。涉及这些对象不需要知道另一个对象---因此鼓励解耦设计模式。这个设计模式经常被用来通知感兴趣的对象当一个属性被改变时候。
通常实现需要一个观察者注册另一个对象感兴趣的状态。当状态改变，所有的观察者对象被通知改变了。苹果的远程通知服务就是一个全球性的例子。
cocoa实现观察者有两个相似的方法：通知和键值观察：
通知：不要被本地通知和远程通知迷惑，通知是根据订阅和通知的模式允许一个对象（通知者）发送消息给另一些对象（订阅者也就是监听者）。这个通知者不需要知道订阅者的任何信息。
苹果公司大量的使用通知，例如当键盘隐藏时候系统发送一个UIKeyboardWillShowNotification/UIKeyboardWillHideNotification通知。当你的应用进入后台系统发送一个UIApplicationDidEnterBackgroundNotification 通知。
键值观察模式：在KVO，一个对象可以要求被通知当他的某个特殊的属性被改变了。
注意：记得要删除你的观察者们当他们收回,否则你的应用程序会崩溃当系统试图将消息发送到这些不存在的观察者!

Block的作用： MyBlock myblock  = ^(int a){
        NSLog(@"参数：%d",a);
        return 10;
   
   int ret =  myblock(20);
  第三种：
    Myblock myblock = ^(int a)
    {
        NSLog(@"这是block代码块，a = %d",a);
        return 10;
    };
    [self testBlock:myblock];
-(void) testBlock:(Myblock) myblock
{
    //可能有一些逻辑判断
    //block回调
    myblock(50);
   
   __block int number = 10;
    Myblock myblock2 = ^(int a)
    {
        number = 20;
        number++;
        NSLog(@"%d",number);
        return 10;
    };     NSObject *obj = [[NSObject alloc] init];
    Myblock *myBlcok = ^(int a)
    {
        //引用计数为2
        NSLog(@"引用计数：%d",obj.retainCount);
        return 10;
    }; NSLog(@"计数：%d",self.retainCount);
    [self objectMethod:^{
        //引用了全局变量number
        int value = number;
        //引用计数2
        NSLog(@"计数：%d",self.retainCount);
        return a +b;

 

4.     Controller的都有什么作用或者controler是怎么工作的呢?加载视图的时候首先会初始化函数(或者实例化)一个controler类的对象,由它来调用自己所在类的方法管理视图,controller所在的类都有哪些方法呢?最典型的方法有loadView方法(加载视图). viewDidLoad(视图加载完成), didReceiveMemoryWarning(内存警告)等.

 

谈谈你对MVC的理解?为什么要用MVC?在Cocoa中MVC是怎么实现的?你还熟悉其他的OC设计模式或别 的设计模式吗?

MVC就是Model-View-Controller的缩写,M指的是业务模型,V指的是用户页面,C指的是控制器。MVC是架构模式,是讲M和 V的代码分离,从而使同那个一个程序可以使用不同的表现形式。 M:表示数据和业务规则,V是用户看到的并与之交互的页面,C是接受用户的输入并调用M和V取完成用户需求的 单例,代理,观察者,工厂模式等 单例模式:说白了就是一个类不通过alloc方式创建对象,而是用一个静态方法返回这个类的对象。系统只需要拥有一个的 全局对象,这样有利于我们协调系统整体的行为; 代理模式:代理模式给某一个对象提供一个代理对象,并由代理对象控制对源对象的引用.比如一个工厂生产了产品,并不想 直接卖给用户,而是搞了很多代理商,用户可以直接找代理商买东西,代理商从工厂进货.常见的如QQ的自动回复就属于代 理拦截,代理模式在iphone中得到广泛应用.

观察者模式: 当一个物体发生变化时,会通知所有观察这个物体的观察者让其做出反应。实现起来无非就是把所有观察者的 对象给这个物体,当这个物体的发生改变,就会调用遍历所有观察者的对象调用观察者的方法从而达到通知观察者的目的

 

 frame:该view在父view坐标系统中的位置和大小。（参照点是，父亲的坐标系统）

简述你对UIView、UIWindow和CALayer的理解 UIView:属于UIkit.framework框架,负责渲染矩形区域的内容,为矩形区域添加动画,响应区域的触摸事件,布局和管 理一个或多个子视图 UIWindow:属于UIKit.framework框架,是一种特殊的UIView,通常在一个程序中只会有一个UIWindow,但可以手 动创建多个UIWindow,同时加到程序里面。UIWindow在程序中主要起到三个作用:

1、作为容器,包含app所要显示的所有视图
  2、传递触摸消息到程序中view和其他对象
  3、与UIViewController协同工作,方便完成设备方向旋转的支持

CAlayer:属于QuartzCore.framework,是用来绘制内容的,对内容进行动画处理依赖与UIView来进行显示,不能处 理用户事件。UIView和CALayer是相互依赖的,UIView依赖CALayer提供内容,CALayer依赖UIView一共容器显示 绘制内容。
延伸: UIViewController:管理视图的几成熟,每个视图控制器都有一个自带的视图,并且负责这个视图相关的一切事务。方便 管理视图中的子视图,负责model与view的通信;检测设备旋转以及内存警告;是所有视图控制类的积累,定义了控制器 的基本功能。

drawRect和layoutSubviews的区别

两个方法都是异步执行的,layoutSubviews方便数据计算,drawRect方便视图重绘。 layoutSubviews对subviews重新布局

layoutSubviews方法调用先于drawRect

 

 

enum {

   UIViewAutoresizingNone                 = 0,

   UIViewAutoresizingFlexibleLeftMargin   = 1 << 0,

   UIViewAutoresizingFlexibleWidth        = 1 << 1,

   UIViewAutoresizingFlexibleRightMargin  = 1 << 2,

   UIViewAutoresizingFlexibleTopMargin    = 1 << 3,

   UIViewAutoresizingFlexibleHeight       = 1 << 4,

   UIViewAutoresizingFlexibleBottomMargin = 1 << 5

};

 

 

UIViewAutoresizingNone就是不自动调整。

UIViewAutoresizingFlexibleLeftMargin 自动调整与superView左边的距离，保证与superView右边的距离不变。

UIViewAutoresizingFlexibleRightMargin 自动调整与superView的右边距离，保证与superView左边的距离不变。

UIViewAutoresizingFlexibleTopMargin 自动调整与superView顶部的距离，保证与superView底部的距离不变。

UIViewAutoresizingFlexibleBottomMargin 自动调整与superView底部的距离，也就是说，与superView顶部的距离不变。

UIViewAutoresizingFlexibleWidth 自动调整自己的宽度，保证与superView左边和右边的距离不变。

UIViewAutoresizingFlexibleHeight 自动调整自己的高度，保证与superView顶部和底部的距离不变。

UIViewAutoresizingFlexibleLeftMargin  |UIViewAutoresizingFlexibleRightMargin 自动调整与superView左边的距离，保证与左边的距离和右边的距离和原来距左边和右边的距离的比例不变。比如原来距离为20，30，调整后的距离应为68，102，即68/20=102/30。

 

下面的方法和对象的编解码（作为归档过程的一部分）有关：
encodeWithCoder:和initWithCoder:是NSCoding协议仅有的方法。前者使对象可以对其实例变量进行编码，后者则使对象可以根据解码过的实例变量对自身进行初始化。
NSObject类中声明了一些于对象编码有关的方法：classForCoder:、replacementObjectForCoder:、和awakeAfterUsingCoder:。

•消息的转发

 forwardInvocation:允许一个对象将消息转发给另一个对象。
•消息的派发 

在performSelector开头的一些方法允许你延迟后派发指定消息，而且可以将消息（同步或异步的消息）从辅助线程派发到主线程。

1：首先多线程技术是耗费资源的比如系统的内存和cpu的占用
2：多线程可能造成两个线程同时访问一块内存来造成资源争夺
3：刚才也说了多线程耗费宝贵的资源，你应该保证你多线程里面执行的操作运行时间长而且有效率。我们还得中断那些空闲的线程。这样有能降低我们应用的内存占用，来腾出内存给其他的应用。
4：线程之间的通信，有时候辅助线程可能要通知主线程做的工作怎么样了。这时候就用到了线程通信的技术。
5：线程的退出，一个线程执行完他的任务自然退出是最好的选择。但是有时候你强制退出一个线程会造成一些内存泄漏等潜在的安全问题。
6：如果你的一个线程突然因为什么原因抛出一个异常。你需要捕获异常，因为同一个进程的线程不能捕获其他线程的异常信息。我们必须把异常情况一个NSException对象从一个线程传递到另一个线程，向这个线程报告发生了什么，这样引发异常的线程可以继续执行(如果有可能)，或者干脆退出。
7：线程浪费宝贵的资源我们需要提高他的效率需要专门一个run loop来处理要执行的事件，有时候还需要一个自动释放池来管理创建的一些临时对象。

 

Grand Central Dispatch（GCD）：
 
系统管理线程，你不需要编写线程代码。只需定义想要执行的任务，然后添加到适当的 dispatch queue。 GCD会负责创建线程和调度你的任务。系统直接提供线程管理，比应用实现更加高效。

GCD，全称Grand Central Dispath，是苹果开发的一种支持并行操作的机制。它的主要部件是一个FIFO队列和一个线程池，前者用来添加任务，后者用来执行任务。
     GCD中的FIFO队列称为dispatch queue，它可以保证先进来的任务先得到执行（但不保证一定先执行结束）。
     通过与线程池的配合，dispatch queue分为下面两种：
•     Serial Dispatch Queue -- 线程池只提供一个线程用来执行任务，所以后一个任务必须等到前一个任务执行结束才能开始。
•     Concurrent Dispatch Queue -- 线程池提供多个线程来执行任务，所以可以按序启动多个任务并发执行。
1. Basic Management
     我们可以通过dispatch_queue_cretae来创建队列，然后用dispatch_release释放。比如下面两段代码分别创建串行队列和并行队列：
dispatch_queue_t serialQ = dispatch_queue_create("eg.gcd.SerialQueue", DISPATCH_QUEUE_SERIAL);
1.dispatch_async(serialQ, ^{  
2.    // Code here  
3.});  
4.dispatch_release(serialQ);

dispatch_queue_t concurrentQ = dispatch_queue_create("eg.gcd.ConcurrentQueue", DISPATCH_QUEUE_CONCURRENT);
1.dispatch_async(concurrentQ, ^{  
2.    // Code here  
3.});  
4.dispatch_release(concurrentQ);


   而系统默认就有一个串行队列main_queue和并行队列global_queue：

1.dispatch_queue_t globalQ = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);  
2.dispatch_queue_t mainQ = dispatch_get_main_queue(); 

2. Normal Control
•dispatch_once
它可以保证整个应用程序生命周期中某段代码只被执行一次！
  •dispatch_after 
有时候我们需要等个几秒钟然后做个动画或者给个提示，这时候可以用dispatch_after这个函数
•dispatch_set_target_queue
         通过dispatch_set_target_queue函数可以设置一个dispatch queue的优先级，或者指定一个dispatch source相应的事件处理提交到哪个queue上。
dispatch_set_target_queue(serialQ, globalQ); 
•dispatch_apply
        执行某个代码片段若干次。
dispatch_apply(10, globalQ, ^(size_t index) {}
•dispatch group
        Dispatch Group机制允许我们监听一组任务是否完成。
•dispatch_barrier_async
     通过dispatch_barrier_async函数提交的任务会等它前面的任务执行结束才开始，然后它后面的任务必须等它执行完毕才能开始。

Operation Queue：
 
Objective-C对象，类似于 dispatch queue。你定义想要执行的任务，并添加任务到 operation queue，后者负责调度和执行这些任务。和 GCD一样， Operation Queue也管理了线程，更加高效
 
asynchronous functions:
系统的一些API接口给你提供了异步的功能自动支持并发功能。这些API也许用系统的机制和进程来创建自定义的线程来执行他们的任务并且返回结果给他们。一旦你设计应用，寻找提供异步功能的API接口来代替用同步放在自定义线程。
timers：
你可以用timers在你的应用主线程来执行周期性的任务这时需要一个线程是太微不足道了。但是仍然要提供每隔一段时间的服务。
 

线程与进程的区别和联系?

谈谈多线程安全问题的几种解决方案?何为线程同步,如何实现的?分线程回调主线程方法是什么,有什么作用?

(1)、多线程的作用:可以解决负载均衡问题,充分利用cpu资源 。为了提高CPU的使用率,采用多线程的方式去同时完 成几件事情而互不干扰,

(2)、大多情况下,要用到多线程的主要是需要处理大量的IO操作时或处理的情况需要花大量的时间等等,比如:读写文 件、视频图像的采集、处理、显示、保存等。 (3)、ios有三种主要方法:1、NSThread。2、NSOperation。3、GCD。 (4)解决方案:使用锁:锁是线程编程同步工具的基础。锁可以让你很容易保护代码中一大块区域以便你可以确保代码的正 确性。使用POSIX互斥锁;使用NSLock类;使用@synchronized指令等。

(5)回到主线程的方法: dispatch_async(dispatch_get_main_queue(), ^{ });

作用:主线程是显示UI界面,子线程多数是进行数据处理

 

归档：NSKeyedArchiver ，NSKeyedUnarchiver

苹果的一个专门记忆模式的实现是归档。把一个对象转化为流便于保存和恢复不用向外部类暴露私有的属性。

 

Core Data是一种 稳定，功能全面的持久化工具，和之前的一些持久化 工具相比，他不需要对实体进行归档，也就是序列化，而是在数据 模型编辑器中创建一些实体
在代码中，你不再使用存取方法和修改方法，而是使用键值对编码来设置属性或者减缩他们的值
那么这些托管对象的活动区域在哪 ？  他们位于所谓的持久库中，默认情况下，Core Data应用程序将持久库实现为存储在应用程序文档目录的sqlite数据库。
虽然数据是通过sqlite存储的，但框架中的类将完成加载和保存数据的相关工作。不许要编写任何sql语句。

sqlite3:
数据库对象：sqlite3          数据库指针：sqlite3_stmt
sqlite3_open():打开数据库
sqlite3_prepare():负责编译sql语句
sqlite3_step():只能得到第一行的内容，继续调用该函数直到所有结果都记录完毕
sqlite3_column():将sqlite3_step运行的结果读出来
sqlite3_finalize():在sqlite3_stmt使用完毕后销毁sqlite3_stmt
sqlite3_close():关闭数据库
sqlite3_exec():执行sql语句
sqlite3_bind_xxx():根据希望使用的数据类型，选择不同的绑定语句。

双表查询

什么是沙盒?沙盒包含哪些文件,描述每个文件的使用场景。如何获取这些文件的路径?如何获取应用程序包 中文件的路径?

 

 

获取这些目录路径的方法:
1,获取家目录路径的函数:
NSString *homeDir = NSHomeDirectory();
2,获取Documents目录路径的方法:
NSArray *paths =NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
NSString *docDir = [paths objectAtIndex:0];
3,获取Caches目录路径的方法:
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
NSString *cachesDir = [paths objectAtIndex:0];
4,获取tmp目录路径的方法:
NSString *tmpDir = NSTemporaryDirectory();
5,获取应用程序程序包中资源文件路径的方法:
例如获取程序包中一个图片资源(apple.png)路径的方法:

NSString *imagePath = [[NSBundle mainBundle] pathForResource:@”apple” ofType:@”png”]; UIImage *appleImage = [[UIImage alloc] initWithContentsOfFile:imagePath]; 代码中的mainBundle类方法用于返回一个代表应用程序包的对象。

计算机网络中五层协议分别是（从下向上）：
1) 物理层
2）数据链路层
3）网络层
4）传输层
5）应用层
其功能分别是：
1）物理层主要负责在物理线路上传输原始的二进制数据；
2）数据链路层主要负责在通信的实体间建立数据链路连接；
3）网络层主要负责创建逻辑链路，以及实现数据包的分片和重组，实现拥塞控制、网络互连等功能；
4）传输曾负责向用户提供端到端的通信服务，实现流量控制以及差错控制；
5）应用层为应用程序提供了网络服务。

一般来说，物理层和数据链路层是由计算机硬件（如网卡）实现的，网络层和传输层由操作系统软件实现，而应用层由应用程序或用户创建实现。

TCP (Transmission Control Protocol)和UDP(User Datagram Protocol)协议属于传输层协议。其中TCP提供IP环境下的数据可靠传输，它提供的服务包括数据流传送、可靠性、有效流控、全双工操作和多路复 用。通过面向连接、端到端和可靠的数据包发送。通俗说，它是事先为所发送的数据开辟出连接好的通道，然后再进行数据发送；而UDP则不为IP提供可靠性、 流控或差错恢复功能。一般来说，TCP对应的是可靠性要求高的应用，而UDP对应的则是可靠性要求低、传输经济的应用。TCP支持的应用协议主要 有：Telnet、FTP、SMTP等；UDP支持的应用层协议主要有：NFS（网络文件系统）、SNMP（简单网络管理协议）、DNS（主域名称系 统）、TFTP（通用文件传输协议）等.

TCP/IP协议与低层的数据链路层和物理层无关，这也是TCP/IP的重要特点

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协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息，则它必须重传，这样可能导致每次连接传送的数据量增大。另一方面，在服务器不需要先前信息时它的应答就较快。

URL

HTTP URL (URL统一资源定位符是一种特殊类型的URI是他的子类，包含了用于查找某个资源的足够的信息)的格式如下：
错误!超链接引用无效。]
http表示要通过HTTP协议来定位网络资源；host表示合法的Internet主机域名或者IP地址；port指定一个端口号，为空则使用缺省端口80；abs_path指定请求资源的URI；如果URL中没有给出abs_path，那么当它作为请求URI时，必须以“/”的形式给出，通常这个工作浏览器自动帮我们完成。

 

#########################################################

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适用于一次只传送少量数据、对可靠性要求不高的应用环境。

 

 

2。也正由于1所说的特点，使得UDP的开销更小数据传输速率更高，因为不必进行收发数据的确认，所以UDP的实时性更好。

tcp协议和udp协议的差别 

是否连接面向连接面向非连接 

传输可靠性可靠不可靠 

应用场合传输大量数据少量数据 

速度慢快

http和scoket通信的区别?socket连接相关库,TCP,UDP的连接方法,HTTP的几种常用方式? http和scoket通信的区别: http是客户端用http协议进行请求,发送请求时候需要封装http请求头,并绑定请求的数据,服务器一般有web服务器配 合(当然也非绝对)。 http请求方式为客户端主动发起请求,服务器才能给响应,一次请求完毕后则断开连接,以节省资 源。服务器不能主动给客户端响应(除非采取http长连接技术)。iphone主要使用类是NSUrlConnection。 scoket是客户端跟服务器直接使用socket“套接字”进行连接,并没有规定连接后断开,所以客户端和服务器可以保持连 接通道,双方都可以主动发送数据。一般在游戏开发或股票开发这种要求即时性很强并且保持发送数据量比较大的场合使 用。主要使用类是CFSocketRef。 UDP:是用户数据报协议:主要用在实时性要求高以及对质量相对较弱的地方,但面对现在高质量的线路不是容易丢包除非 是一些拥塞条件下 ,如流媒体 TCP:是传输控制协议:是面连接的,那么运行环境必然要求其可靠性不可丢包有良好的拥塞控制机制如http ftp telnet 等

http的常用方式:get,post

 

你连接服务器用的是什么方法,如果请求过程中,网络出了问题这么办?

 

第三方静态库包含私有api的调用(联系第三方技术支持,更新静态库); 包含潜在的色情,暴力等内容(调整应用年龄限制等级,并加入举报功能) 做浏览器的,分级必须选17+

什么是push?远程推送?
第一步:UIApplication向APNS注册push notification服务
1、应用程序 要支持 推送服务(在网页里配置) (1)https://developer.apple.com/devcenter/ios/index.action
(2)登录 苹果开发者账号(注意是收费账号,$99或$299) 3)下载push证书(主要是给程序签名,push服务只有收费开发者才具备。所以需要签名验证),如果没有 push证书,创建一个push证书(App ID->钥匙串程序生成request->push证书)注意事项:App ID的 Bundle ID必须和程序plist文件里的Bundle identifier一致。App ID一旦生成,将不可修改。 (4)把证书安装到钥匙串里(双击证书文件)
(5)生成 编译程序 用的描述文件(网页里进行) 2、向APNS注册push服务(UIApplication的registerForRemoteNotificationTypes:方法)
第二步 获取APNS分配的DeviceToken(64位16进制串)
- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken
第三步 把DeviceToken发送给自己的后台服务器,服务器记录每台设备的DeviceToken以便日后推送信息给客 户端。(需要有一个网络接口,让客户端发送DeviceToken)
第四步 服务器推送信息给客户端 1、服务器除了需要有客户端的DeviceToken之外,还要有push证书,对push的内容进行签名。(苹果为了防 止 恶意向客户端(比如DeviceToken泄露了)发送消息,每次推送消息,都需要证书进行签名,从而避免黑客恶 意攻击用户手机。) 2、如果你的服务器是java写的,可以直接使用钥匙串导出的p12文件(证书和密钥一起导出)。如果你的服务器 是php写的,因为php语言不支持p12文件类型,需要转换为pem文件。
3、将p12转换为pem文件:终端 先找到你p12所在的目录 openssl pkcs12 -in CertificateName.p12 - outCertificateName.pem -nodes
4、服务器发送信息给APNS,APNS自动将信息推送给客户端
第五步 客户端处理收到的信息
- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo

 

1、测试版的push证书仅仅用于开发期间测试,发布版的程序需要生成一个发布版的push证书。 2、测试版APNS的ssl地址和发布版的ssl地址不同 3、测试版的DeviceToken和发布版的DeviceToken也不同
4、php文件要喝pem文件放在同一目录。
5、除了alert sound和badge之外,json串里还可以包含自定义信息。
6、推送的信息最大255字节 7、推送的信息受网络影响较大,有可能造成延迟甚至丢失,重要信息的传递不应该使用push通知,应该有专门的 后台接口。

 

 

 

 

1. - (void)testAccessVariable 
2. { 
3.     NSInteger outsideVariable = 10; 
4.     //__block NSInteger outsideVariable = 10; 
5.     NSMutableArray * outsideArray = [[NSMutableArray alloc] init]; 
6.      
7.     void (^blockObject)(void) = ^(void){ 
8.         NSInteger insideVariable = 20; 
9.         KSLog(@"  > member variable = %d", self.memberVariable); 
10.         KSLog(@"  > outside variable = %d", outsideVariable); 
11.         KSLog(@"  > inside variable = %d", insideVariable); 
12.          
13.         [outsideArray addObject:@"AddedInsideBlock"]; 
14.     }; 
15.      
16.     outsideVariable = 30; 
17.     self.memberVariable = 30; 
18.  
19.     blockObject(); 
20.      
21.     KSLog(@"  > %d items in outsideArray", [outsideArray count]); 
22. } 

1. > member variable = 30 
2. > outside variable = 10 
3. > inside variable = 20 
4. > 1 items in outsideArray 

1. typedef NSString* (^IntToStringConverter)(id self, NSInteger paramInteger); 
2. - (NSString *) convertIntToString:(NSInteger)paramInteger 
3.                  usingBlockObject:(IntToStringConverter)paramBlockObject 
4. { 
5.     return paramBlockObject(self, paramInteger); 
6. } 
7.  
8. typedef NSString* (^IntToStringInlineConverter)(NSInteger paramInteger); 
9. - (NSString *) convertIntToStringInline:(NSInteger)paramInteger 
10.                  usingBlockObject:(IntToStringInlineConverter)paramBlockObject 
11. { 
12.     return paramBlockObject(paramInteger); 
13. } 
14.  
15. IntToStringConverter independentBlockObject = ^(id self, NSInteger paramInteger) { 
16.     KSLog(@" >> self %@, memberVariable %d", self, [self memberVariable]); 
17.      
18.     NSString *result = [NSString stringWithFormat:@"%d", paramInteger]; 
19.     KSLog(@" >> independentBlockObject %@", result); 
20.     return result; 
21. }; 
22.  
23. - (void)testAccessSelf 
24. { 
25.     // Independent 
26.     // 
27.     [self convertIntToString:20 usingBlockObject:independentBlockObject]; 
28.      
29.     // Inline 
30.     // 
31.     IntToStringInlineConverter inlineBlockObject = ^(NSInteger paramInteger) { 
32.         KSLog(@" >> self %@, memberVariable %d", self, self.memberVariable); 
33.          
34.         NSString *result = [NSString stringWithFormat:@"%d", paramInteger]; 
35.         KSLog(@" >> inlineBlockObject %@", result); 
36.         return result; 
37.     }; 
38.     [self convertIntToStringInline:20 usingBlockObject:inlineBlockObject]; 
39. } 

1. @interface KSViewController () 
2. { 
3.     id _observer; 
4. } 
5.  
6. @end 
7.  
8. @implementation KSViewController 
9.  
10. - (void)viewDidLoad 
11. { 
12.     [super viewDidLoad]; 
13.     // Do any additional setup after loading the view, typically from a nib. 
14.      
15.     KSTester * tester = [[KSTester alloc] init]; 
16.     [tester run]; 
17.      
18.     _observer = [[NSNotificationCenter defaultCenter] 
19.                  addObserverForName:@"TestNotificationKey" 
20.                  object:nil queue:nil usingBlock:^(NSNotification *n) { 
21.                      NSLog(@"%@", self); 
22.                  }]; 
23. } 
24.  
25. - (void)dealloc 
26. { 
27.     if (_observer) { 
28.         [[NSNotificationCenter defaultCenter] removeObserver:_observer]; 
29.     } 
30. } 

1. __weak KSViewController * wself = self; 
2. _observer = [[NSNotificationCenter defaultCenter] 
3.              addObserverForName:@"TestNotificationKey" 
4.              object:nil queue:nil usingBlock:^(NSNotification *n) { 
5.                  KSViewController * sself = wself; 
6.                  if (sself) { 
7.                      NSLog(@"%@", sself); 
8.                  } 
9.                  else { 
10.                      NSLog(@"<self> dealloc before we could run this code."); 
11.                  } 
12.              }]; 

1. - (id) getBlockArray 
2. { 
3.     int val = 10; 
4.     return [[NSArray alloc] initWithObjects: 
5.             ^{ KSLog(@"  > block 0:%d", val); },    // block on the stack 
6.             ^{ KSLog(@"  > block 1:%d", val); },    // block on the stack 
7.             nil]; 
8.      
9. //    return [[NSArray alloc] initWithObjects: 
10. //            [^{ KSLog(@"  > block 0:%d", val); } copy],    // block copy to heap 
11. //            [^{ KSLog(@"  > block 1:%d", val); } copy],    // block copy to heap 
12. //            nil]; 
13. } 
14.  
15. - (void)testManageBlockMemory 
16. { 
17.     id obj = [self getBlockArray]; 
18.     typedef void (^BlockType)(void); 
19.     BlockType blockObject = (BlockType)[obj objectAtIndex:0]; 
20.     blockObject(); 
21. }