动态绑定-运行时确定要调用的方法
Gategory类别的作用？
分别描述类别(categories)和延展(extensions)是什么?以及两者的区别?继承和类别在实现中有何区
别?为什么Category只能为对象添加方法,却不能添加成员变量?
类别:在没有原类.m文件的基础上,给该类添加方法; 延展:一种特殊形式的类别,主要在一个类的.m文件里声明和实现延展的作用,就是给某类添加私有方法或是私有变量。 两个的区别:延展可以添加属性并且它添加的方法是必须要实现的。延展可以认为是一个私有的类目。 继承和类别在实现中的区别:类别可以在不获悉,不改变原来代码的情况下往里面添加新的方法,只能添加,不能删除修 改。并且如果类别和原来类中的方法产生名称冲突,则类别将覆盖原来的方法,因为类别具有更高的优先级。 Category只能为对象添加方法,却不能添加成员变量的原因:如果可以添加成员变量,添加的成员变量没有办法初始 化----这是语言规则
– (void)thisIsAnInstanceMethod;
@end
@private可以用来修饰私有变量
在Objective‐C中，所有实例变量默认都是私有的，所有实例方法默认都是公有的
if ([device respondsToSelector:@selector(isMultitaskingSupported)])
目标-动作机制 目标是动作消息的接收者。一个控件,或者更为常见的是它的单元,以插座变量的形式保有其动作消息的目标。
那么先让我们来看一看下边数组类型的转换
1、不可变对象→可变对象的转换：
NSArray *array1= [NSArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];
NSMutableArray *str2=[array1 mutableCopy];
2、可变对象→不可变对象的转换：
NSMutableArray *array2 = [NSMutableArray arrayWithObjects:@"aa",@"bb",@"cc",@"dd",nil];
NSArray *array1=[ array2 Copy];
3、可变对象→可变对象的转换（不同指针变量指向不同的内存地址）：
NSMutableArray *array1= [NSMutableArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];
NSMutableArray *str2=[array1 mutableCopy];
通过上边的两个例子，我们可轻松的将一个对象在可变和不可变之间转换，并且这里不用考虑内存使用原则（即引用计数的问题）。没错，这就是深拷贝的魅力了。
4、同类型对象之间的指针复制（不同指针变量指向同一块内存地址）：
NSMutableString *str2=[str1 retain];
NSArray *array1= [NSArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];
NSArray *str2=[array1 Copy];
2) 在mm文件中混用cpp直接使用即可,所以obj-c混cpp不是问题
3)在cpp中混用obj- c其实就是使用obj-c编写的模块是我们想要的。如果模块以类实现,那么要按照cpp class的标准写类的定 义,头文件中不能出现obj-c的东西,包括#import cocoa的。 实现文件中,即类的实现代码中可以使用obj-c的东西,可以import,只是后缀是mm。如果模块以函数实现,那么头文件要按 c的格 式声明函数,实现文件中,c++函数内部可以用obj-c,但后缀还是mm或m。总结:只要cpp文件和cpp include的文件中不包含 obj-c的东西就可以用了,cpp混用obj-c的关键是使用接口,而不能直接使用实现代码,实际上cpp混用的是obj-c编译后的o文 件,这个东西其实是无差别的,所以可以用。obj-c的编译器支持cpp。
Foundation.framework,CoreGraphics.framework,UIKit.framework, MediaPlayer.framework, CoreAudio.framework
比如:本地化应用程序名称
(1、选中工程,Info—Localizations点击“+”添加要国际化的语言。 (2、在InfoPlist.strings右边会多出一个三角形,点击展开可看到InfoPlish.strings(english)和
InfoPlish.strings(chinese)两个版本的文件; (3、在InfoPlish.strings(english)文件中加入:
CFBundleDisplayName ="Program"; 其中“Program”为英文应用程序名称,同理在InfoPlish.strings(chinese)文件中加入: CFBundleDisplayName ="应用程序"; 其中“应用程序”为中文名称,注意:CFBundleDisplayName加不加双引号都行;
· Other Sources-> main.m 等,不需要程序员修改 -Prefix.pch
· Resources -> 界面文件(.xib)、配置文件-info.plist
· Frameworks -> 链接的库· Targets -> 项目的不同Target(资源、编译配置不同)
关键字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 类型，以使得其返回值不为“左值”。
• 并行设备的硬件寄存器（如：状态寄存器）
• 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
• 多线程应用中被几个任务共享的变量
• 一个参数既可以是const还可以是volatile吗？解释为什么。
• 一个指针可以是volatile 吗？解释为什么。
下面是答案：
• 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
• 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
static作用？
函数体内 static 变量的作用范围为该函数体，不同于 auto 变量，该变量的内存只被分配一次，
因此其值在下次调用时仍维持上次的值；
（2）在模块内的 static 全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；
（3）在模块内的 static 函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明
它的模块内；
（4）在类中的 static 成员变量属于整个类所拥有，对类的所有对象只有一份拷贝；
（5）在类中的 static 成员函数属于整个类所拥有，这个函数不接收 this 指针，因而只能访问类的static 成员变量。
进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。
进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。
1.当你使用new,alloc和copy方法创建一个对象时,该对象的保留计数器值为1.当你不再使用该对象时,你要负责向该对象发送一条release或autorelease消息.这样,该对象将在使用寿命结束时被销毁.
2.当你通过任何其他方法获得一个对象时,则假设该对象的保留计数器值为1,而且已经被设置为自动释放,你不需要执行任何操作来确保该对象被清理.如果你打算在一段时间内拥有该对象,则需要保留它并确保在操作完成时释放它.
3.如果你保留了某个对象,你需要(最终)释放或自动释放该对象.必须保持retain方法和release方法的使用次数相等.
为什么很多内置的类，如TableViewController的delegate的属性是assign不是retain？
所有的引用计数系统，都存在循环应用的问题。例如下面的引用关系：
• 对象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永远留在内存中。
定义属性时，什么情况使用copy、assign、retain？
assign用于简单数据类型，如NSInteger,double,bool,
retain和copy用于对象，
copy用于当a指向一个对象，b也想指向同样的对象的时候，如果用assign，a如果释放，再调用b会crash,如果用copy 的方式，a和b各自有自己的内存，就可以解决这个问题。
retain 会使计数器加一，也可以解决assign的问题。
另外：atomic和nonatomic用来决定编译器生成的getter和setter是否为原子操作。在多线程环境下，原子操作是必要的，否则有可能引起错误的结果。
加了atomic，setter函数会变成下面这样：
if (property != newValue) {
[property release];
property = [newValue retain];
}
对象是什么时候被release的？
readwrite,readonly,assign,retain,copy,nonatomic 、strong、weak属性的作用?并区别
strong(强引用)、 weak(弱引用)?什么情况使用copy,assign,和retain?
readonly 是只读特性 只会生成getter方法 不会生成setter方法 ;不希望属性在类外改变
assign 是赋值特性,setter方法将传入参数赋值给实例变量;仅设置变量时;
retain 表示持有特性,setter方法将传入参数先保留,再赋值,传入参数的retaincount会+1;
copy 表示赋值特性,setter方法将传入对象复制一份;需要完全一份新的变量时。
nonatomic 非原子操作,决定编译器生成的setter getter是否是原子操作,atomic表示多线程安全,一般使用 nonatomic
assign用于简单数据类型,如NSInteger,double,bool。
* 对象a创建并引用到了对象b. * 对象b创建并引用到了对象c. * 对象c创建并引用到了对象b.
是release,为什么?
与retain配对使用的方法是release,因为retain使retainCount计数加1,release使retainCount计数减1;与 retain语义相反的是release。 与alloc配对使用的是release,因为:alloc是使retainCount计数加1,,使retainCount计数减1。与alloc语义相反
的是dealloc,因为:alloc是创建一个对象,,dealloc是销毁一个对象。
16、重写一个NSStrng类型的,retain方式声明name属性的setter和getter方法 { NSString * _name; } @property NSString *name;----加上这些是为了避免错误
-(void)setName:(NSString*)name
{
{[_name release];
_name=[name retain];
}
和[NSAutoreleasePool drain]有什么区别?
内存管理要点:
Objective-C 使用引用计数机制(retainCount)来管理内存。内存每被引用一次,该内存的引用计数+1,每被释放一次引 用计数-1。当引用计数 = 0 的时候,调用该对象的 dealloc 方法,来彻底从内存中删除该对象。 alloc,allocWithZone,new(带初始化)时:该对象引用计数 +1;
retain:手动为该对象引用计数 +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做两件事情：
-
处于等待的状态直到某件事情发生（比如想接受一个信息）
-
分配信息给需要接收的对象
所以从上面的讲述就可以知道，RunLoop的工作实际上就是在等待触发事件的发生。这些触发事件可以是外部的事件，比如用户的一些行为或者像网络 请求，又或者像App内部的信息，比如线程内部的通知，异步代码的执行，定时器等等，一旦一个触发事件发生，并且RunLoop接受到这个信息，它就会去 寻找相关的收信人，并把信息发送给这个收信人。
-
通知观察者RunLoop已经被启动
-
通知观察者一些定时器已经准备开始
-
通知观察者一些不是基于端口的输入源准备开始
-
启动那些已经准备好的不是基于端口的输入源
-
如果一个基于端口的输入源已经准备好，正等待被启动，那么就会马上启动这个输入源。进入第9步。
-
通知观察者这个线程准备休眠。
-
把这个线程变成休眠状态直到下面一个事件发生：
-
-
一个事件到达了一个基于端口的源
-
一个定时器启动
-
RunLoop设置的时间已经到时
-
该RunLoop被唤醒
-
-
通知观察者该线程被唤醒
-
处理等待事件
-
-
如果一个用户定义的定时器启动，处理这个定时器并且进入下一个RunLoop，进入第2步。
-
如果一个输入源启动，传递这个事件
-
如果这个RunLoop被唤醒，但是还超过设置的超时时间，那么就进入下一个RunLoop，进入第2步。
-
-
通知观察者RunLoop退出。
Key-Value Coding（KVC）实现分析
KVC运用了一个isa-swizzling技术。isa-swizzling就是类型混合指针机制。KVC主要通过isa-swizzling，来实现其内部查找定位的。isa指针，如其名称所指，（就是is a kind of的意思），指向维护分发表的对象的类。该分发表实际上包含了指向实现类中的方法的指针，和其它数据。
比如说如下的一行KVC的代码：
- [site setValue:@"sitename" forKey:@"name"];
- SEL sel = sel_get_uid ("setValue:forKey:");
- IMP method = objc_msg_lookup (site-]] > isa,sel);
- method(site, sel, @"sitename", @"name");
KVC和KVO的使用原则：
一、KVC(key-value-coding)
1、只针对类属性，设置键值对
2、设置setValue: forKey:，即forKey只能为类属性
3、取值valueForKey
二、KVO(key-value-observing)被观察者的属性发生改变时，通知观察者
1、利用KVC对类属性进行设置
2、注册observing对象addObserver:forKeyPath:options:context:
3、观察者类必须重写方法 observeValueForKeyPath:ofObject:change:context:
4、应用，MVC模型中，数据库（dataModal）发生变化时，引起view改变，用这种方式实现非常方便
优点：
1.设置值,会查找属性的getter（valueForKey）和setter（setValueForKey）方法，然后查找其名字的实例变量。
2.支持指定键路径，就像文件系统的路径一样。比如：car.emgine.horespower
3.整体操作，比如：给一个汽车的轮子发送kvc消息，由于汽车有4个轮子，调用代码(valueForKeyPath:@“tires.pressure”)后会返回一个数组（包含4个数据）。
4.快速运算:可以引用一些运算符来进行一些计算。如:cars.@count,[email protected] (cars.用来获取cars的属性，@count中@符号代表着后面将进行一些运算，@count用于通知kvc机制计算键路径左侧值的对象总数。同理，后者是计算所有对象的平均行驶距离)。 但是你还不能添加自己的运算符。
5.批处理：有两个调用可以为对象进行批量处理。第一个调用为：dictionaryWithValueForKey。第二个调用为：setValueForKeyWithDictinary
6.nil仍然可用:重写setNilValueForKey方法
7.处理未定义的键:重写valueForUndefinedKey方法
缺点：
(Key-Value Coding查找方法的时候，不仅仅会查找someKey这个方法，还会查找getsomeKey这个方法，前面加一个get，或者_someKey以及_getsomeKey这几种形式。同时，查找实例变量的时候也会不仅仅查找someKey这个变量，也会查找_someKey这个变量是否存在。)
那么在苹果开发过程中，用到委托的程序实现思想如下，我主要拿如何在视图之间传输信息做个例子。
譬如：在两个页面（UIIview视图对象）实现传值，用委托（delegate）可以很好做到！
方法：
类A
@interface A：UIView
id transparendValueDelegate;
@property(nomatic, retain) idtransparendValueDelegate;
@end
@implemtion A
@synthesize transparendValueDelegate
-(void)Function
{
NSString* value = @"hello";
//让代理对象执行transparendValue动作
[transparendValueDelegate transparendValue:value];
}
@end
类B
@interface B：UIView
NSString* value;
@end
@implemtion B
-(void)transparendValue:(NSString*)fromValue
{
value = fromValue;
NSLog(@"the value is %@",value);
}
@end
//下面的设置A代理委托对象为B
//在定义A和B类对象处：
A* a = [[A alloc] init];
B* b = [[B alloc] init];
a. transparendValueDelegate = b;//设置对象a代理为对象b
这样在视图A和B之间可以通过委托来传值！
下面这个例子委托有两类：
1、一个视图类对象的代理对象为父视图，子视图用代理实现让父视图显示别的子视图
2、同一父视图下的一个子视图为另一个子视图的代理对象，让另一个子视图改变自身背景色为给定的颜色
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
规范格式如下：
@protocol TransparendValueDelegate;
@interface A：UIView
id< TransparendValueDelegate > m_dTransparendValueDelegate;
@property(nomatic, retain) id m_dTransparendValueDelegate;
@end
//代理协议的声明
@protocol TransparendValueDelegat
{
-(void)transparendValue:(NSString*)fromValue;
}
block的三种类型：NSGlobalBlock，NSStackBlock，NSMallocBlock
GlobalBlock呢？因为它不需要运行时(Runtime)任何的状态来改变行为，不需要放在堆上或者栈上，直接编译后在代码段中即可，就像个c函数一样。这种类型的Block在ARC和non-ARC情况下没有差别。
StackBlock呢？这个Block访问了作用域外的变量d，在实现上就是这个block会多一个成员变量对应这个d，在赋值block时会将方法exmpale中的d变量值复制到成员变量中，从而实现访问。由于局部变量d和这个block的实现不在同一作用域，仅仅在调用过程中用到了值传递，所以不能直接修改。而需要加一个标识符__block;，这样对Block外的变量访问从值传递转变为引用，从而有了修改内容的能力。那么block就可以实现对这个局部变量的修改了。
MallocBlock呢？正常我们使用Block是在栈上生成的，离开了栈作用域便释放了，如果copy一个Block，那么会将这个Block copy到堆上分配，这样就不再受栈的限制，可以随意使用啦。
Block一开始是在栈上分配的，属于NSStackBlock，如果是non-ARC情况下return这个NSStackBlock，那么其实已经被销毁了，在函数中使用时就会crash。如果是ARC情况下，getBlock返回的block会自动copy到堆上，那么block的类型就是NSMallocBlock，可以在example()中继续使用。所以，如果是non-ARC时，要写明[block copy]。
Block的循环引用问题：
retain cycle问题的根源在于Block和obj可能会互相强引用，互相retain对方，这样就导致了retain cycle，最后这个Block和obj就变成了孤岛，谁也释放不了谁。
在Block中虽然没直接使用self，但使用了成员变量。在Block中使用成员变量，retain的不是这个变量，而会retain self。
注意：MRC中 __block 是不会引起retain；但在ARC中 __block 则会引起retain。ARC中应该使用 __weak 或 __unsafe_unretained 弱引用。 __weak 只能在iOS5以后使用。
开发者必须要注意对象和Block的生命周期。
__block不要乱用:
将Block作为参数传给dispatch_async时，系统会将Block拷贝到堆上，如果Block中使用了实例变量，还将retain self，因为dispatch_async并不知道self会在什么时候被释放，为了确保系统调度执行Block中的任务时self没有被意外释放掉，dispatch_async必须自己retain一次self，任务完成后再release self。但这里使用__block，使dispatch_async没有增加self的引用计数，这使得在系统在调度执行Block之前，self可能已被销毁，但系统并不知道这个情况，导致Block被调度执行时self已经被释放导致crash
BLOCK用处：
1.回调传值 2.作为方法的参数，在block里面定义任意的代码段。
5.单例，代理，观察者模式，mvc框架
单例:单例模式的意思就是只有一个实例。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。
1.单例模式的要点：
单例设计模式确保这个类仅仅拥有一个实例，并且为这个实例提供一个全局的访问点。
apple用了很多的单例：[NSUserDefaults
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，一个对象可以要求被通知当他的某个特殊的属性被改变了。
注意：记得要删除你的观察者们当他们收回,否则你的应用程序会崩溃当系统试图将消息发送到这些不存在的观察者!
NSLog(@"参数：%d",a);
return 10;
第三种：
{
NSLog(@"这是block代码块，a = %d",a);
return 10;
};
[self testBlock:myblock];
-(void) testBlock:(Myblock) myblock
{
//可能有一些逻辑判断
//block回调
myblock(50);
Myblock myblock2 = ^(int a)
{
number = 20;
number++;
NSLog(@"%d",number);
return 10;
};
Myblock *myBlcok = ^(int a)
{
//引用计数为2
NSLog(@"引用计数：%d",obj.retainCount);
return 10;
};
[self objectMethod:^{
//引用了全局变量number
int value = number;
//引用计数2
NSLog(@"计数：%d",self.retainCount);
return a +b;
iOS程序运行流程｛
1. 系统调用app的main函数
2. main函数调用UIApplicationMain.
3. UIApplicationMain创建sharedapplication instance, UIApplication默认的instance.
4. UIApplicationMain读取Info.plist找到主nib文件, 加载nib，把shared applicationinstance 设为nib的owner.
5. 通过nib文件，创建app的独立UIWindows object.
6. 通过nib，实例化了程序的AppDelegate object.
7. app内部启动结束，application:didFinishLaunchingWith-Options: 被设定成 wAppDelegate instance.
8. AppDelegate向UIWindowinstance发makeKeyAndVisible消息, app界面展示给用户. app准备好接收用户的操作指令.
｝
怎么理解MVC，在Cocoa中MVC是怎么实现的？
MVC设计模式考虑三种对象：模型对象、视图对象、和控制器对象。模型对象代表特别的知识和专业技能，它们负责保有应用程序的数据和定义操作数据的逻辑。视图对象知道如何显示应用程序的模型数据，而且可能允许用户对其进行编辑。控制器对象是应用程序的视图对象和模型对象之间的协调者。
MVC就是Model-View-Controller的缩写,M指的是业务模型,V指的是用户页面,C指的是控制器。MVC是架构模式,是讲M和 V的代码分离,从而使同那个一个程序可以使用不同的表现形式。 M:表示数据和业务规则,V是用户看到的并与之交互的页面,C是接受用户的输入并调用M和V取完成用户需求的 单例,代理,观察者,工厂模式等 单例模式:说白了就是一个类不通过alloc方式创建对象,而是用一个静态方法返回这个类的对象。系统只需要拥有一个的 全局对象,这样有利于我们协调系统整体的行为; 代理模式:代理模式给某一个对象提供一个代理对象,并由代理对象控制对源对象的引用.比如一个工厂生产了产品,并不想 直接卖给用户,而是搞了很多代理商,用户可以直接找代理商买东西,代理商从工厂进货.常见的如QQ的自动回复就属于代 理拦截,代理模式在iphone中得到广泛应用.
观察者模式: 当一个物体发生变化时,会通知所有观察这个物体的观察者让其做出反应。实现起来无非就是把所有观察者的 对象给这个物体,当这个物体的发生改变,就会调用遍历所有观察者的对象调用观察者的方法从而达到通知观察者的目的
frame:该view在父view坐标系统中的位置和大小。（参照点是，父亲的坐标系统）
1、作为容器,包含app所要显示的所有视图
2、传递触摸消息到程序中view和其他对象
3、与UIViewController协同工作,方便完成设备方向旋转的支持
CAlayer:属于QuartzCore.framework,是用来绘制内容的,对内容进行动画处理依赖与UIView来进行显示,不能处 理用户事件。UIView和CALayer是相互依赖的,UIView依赖CALayer提供内容,CALayer依赖UIView一共容器显示 绘制内容。
延伸: UIViewController:管理视图的几成熟,每个视图控制器都有一个自带的视图,并且负责这个视图相关的一切事务。方便 管理视图中的子视图,负责model与view的通信;检测设备旋转以及内存警告;是所有视图控制类的积累,定义了控制器 的基本功能。
alloc和allocWithZone:方法用于从某内存区域中分配一个对象内存，并使对象指向其运行时的类定义。
init方法是对象初始化。
new是一个将简单的内存分配和初始化结合起来的方法。
copy和copyWithZone:
•对象的保持和清理：
retain方法增加对象的保持次数。
release方法减少对象的保持次数。
autorelease方法也是减少对象的保持次数，但是以推迟的方式。
retainCount方法返回对当前的保持次数。
dealloc方法由需要释放对象的实例变量以及释放动态分配的内存的类实现。
encodeWithCoder:和initWithCoder:是NSCoding协议仅有的方法。前者使对象可以对其实例变量进行编码，后者则使对象可以根据解码过的实例变量对自身进行初始化。
NSObject类中声明了一些于对象编码有关的方法：classForCoder:、replacementObjectForCoder:、和awakeAfterUsingCoder:。
•消息的转发
forwardInvocation:允许一个对象将消息转发给另一个对象。
•消息的派发
在performSelector开头的一些方法允许你延迟后派发指定消息，而且可以将消息（同步或异步的消息）从辅助线程派发到主线程。
l 线程(线程)用于指代独立执行的代码段。
l 进程(process)用于指代一个正在运行的可执行程序，它可以包含多个线程。
l 任务(task)用于指代抽象的概念，表示需要执行工作。
我们可以这样理解：我们可以在电脑上开启多个QQ应用。每个QQ应用可以同时打开很多聊天的窗口。这里每个QQ是一个进程，然后每个QQ聊天窗口是一个QQ应用的一个线程。
这三种编程方式从上到下，抽象度层次是从低到高，抽象程度越高的使用越简单，也是Apple最推荐使用的。
三种方式的优缺点：
NSThread
优点：NSThread比其他两个轻量级
缺点：需要自己管理线程的生命周期，线程同步。线程同步对数据的加锁会有一定的系统开销。
Cocoa operation
优点：不需要关心线程管理，数据同步的事情，可以把精力放在自己需要执行的操作上。Cocoa operation相关的类是NSOperation ， NSOperationQueue。 NSOperation是个抽象类，使用它必须使用它的子类，可以实现它或者使用它定义好的两个子类：NSInvocationOperation 和 NSBlockOperation 。 创建NSoperation子类的对象，把对象添加到NSoperationQueue队列里执行。
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界面,子线程多数是进行数据处理
Core Data不是一个关系型数据库,也不是关系型数据库管理系统(RDBMS)。虽然Core Dta支持SQLite作为一种存储类型, 但它不能使用任意的SQLite数据库。Core Data在使用的过程种自己创建这个数据库。Core Data支持对一、对多的关系。
第四种：文件写入磁盘
NSUserDefaults类的使用和NSKeyedArchiver有很多类似之处，但是查看NSUserDefaults的定义可以看出，NSUserDefaults直接继承自NSObject而NSKeyedArchiver 继承自NSCoder。这意味着NSKeyedArchiver实际上是个归档持久化的类，也就可以使用NSCoder类的［encodeObject: (id)objv forKey:(NSString *)key］方法来对数据进行持久化存储
(void)encodeWithCoder:( NSCoder *)aCoder
(id)initWithCoder:( NSCoder *)aDecoder
在代码中，你不再使用存取方法和修改方法，而是使用键值对编码来设置属性或者减缩他们的值
那么这些托管对象的活动区域在哪 ？ 他们位于所谓的持久库中，默认情况下，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():根据希望使用的数据类型，选择不同的绑定语句。
什么是沙盒?沙盒包含哪些文件,描述每个文件的使用场景。如何获取这些文件的路径?如何获取应用程序包 中文件的路径?
Documents 目录:您应该将所有de应用程序数据文件写入到这个目录下。这个目录用于存储用户数据或其它应该定期备 份的信息。AppName.app 目录:这是应用程序的程序包目录,包含应用程序的本身。由于应用程序必须经过签名,所以 您在运行时不能对这个目录中的内容进行修改,否则可能会使应用程序无法启动。Library 目录:这个目录下有两个子目 录:Caches 和 PreferencesPreferences 目录包含应用程序的偏好设置文件。您不应该直接创建偏好设置文件,而是 应该使用NSUserDefaults类来取得和设置应用程序的偏好.Caches 目录用于存放应用程序专用的支持文件,保存应用程 序再次启动过程中需要的信息。tmp 目录:这个目录用于存放临时文件,保存应用程序再次启动过程中不需要的信息。
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)路径的方法:
◆可读性
JSON(Java Object Notation) 和XML的可读性可谓不相上下，一边是建议的语法，一边是规范的标签形式，很难分出胜负。
◆可扩展性
XML和JSON都使用结构化方法来标记数据
2、DOM 以及广义的基于树的处理具有几个优点。首先,由于树在内存中是持久的,因此可以修改它以便应用程序能对数 据和结构作出更改。它还可以在任何时候在树中上下 导航,而不是像 SAX 那样是一次性的处理。DOM 使用起来也要简单 得多。另一方面,在内存中构造这样的树涉及大量的开销。大型文件完全占用系统内存容量的情况并不鲜见。此外,创建一 棵 DOM 树可能是一个缓慢的过程。
3、选择 DOM 还是选择 SAX,这取决于下面几个因素:
应用程序的目的:如果打算对数据作出更改并将它输出为 XML,那么在大多数情况下,DOM 是适当的选择。并不是说使 用 SAX 就不能更改数据,但是该过程要复杂得多,因为您必须对数据的一份拷贝而不是对数据本身作出更改。
数据容量: 对于大型文件,SAX 是更好的选择。数据将如何使用:如果只有数据中的少量部分会被使用,那么使用 SAX 来将该部分数据提取到应用程序中可能更好。 另一方面,如果您知道自己以后会回头引用已处理过的大量信息,那么 SAX 也许不是恰当的选择。
对速度的需要:SAX 实现通常要比 DOM 实现更快。
•DOM解析XML时，读入整个XML文档并构建一个驻留内存的树结构（节点树），通过遍历树结构可以检索任意XML节点，读取它的属性和值。而且通常情况下，可以借助XPath，直接查询XML节点。
•SAX解析XML，是基于事件通知的模式，一边读取XML文档一边处理，不必等整个文档加载完之后才采取操作，当在读取解析过程中遇到需要处理的对象，会发出通知对其进行处理。
一般在iOS平台下，比较常用的XML解析类库有如下几种：
•如果是读取很小的XML文档，性能基本上没有什么差别，不过从调用的方便性来说，建议使用TouchXML、KissXML或GDataXML
•如果是需要读取和修改XML文档，建议使用KissXML或GDataXML
•如果需要读取非常大的XML文档，则建议使用libxml2或TBXML
计算机网络中五层协议分别是（从下向上）：
1) 物理层
2）数据链路层
3）网络层
4）传输层
5）应用层
其功能分别是：
1）物理层主要负责在物理线路上传输原始的二进制数据；
2）数据链路层主要负责在通信的实体间建立数据链路连接；
3）网络层主要负责创建逻辑链路，以及实现数据包的分片和重组，实现拥塞控制、网络互连等功能；
4）传输曾负责向用户提供端到端的通信服务，实现流量控制以及差错控制；
5）应用层为应用程序提供了网络服务。
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适用于一次只传送少量数据、对可靠性要求不高的应用环境。
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、打开、关闭），这些函数我们在后面进行介绍。
Socket连接与HTTP连接
我们在传输数据时，可以只使用（传输层）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协议的抽象，从而形成了我们知道的一些最基本的函数接口。
下面是一些的重要的概念，特在此做摘抄和总结。
一。什么是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连接的请求，断开过程需要经过“四次握手”（过程就不细写了，就是服务器和客户端交互，最终确定断开）
二。利用Socket建立网络连接的步骤
建立Socket连接至少需要一对套接字，其中一个运行于客户端，称为ClientSocket ，另一个运行于服务器端，称为ServerSocket 。
套接字之间的连接过程分为三个步骤：服务器监听，客户端请求，连接确认。
1。服务器监听：服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态，等待客户端的连接请求。
2。客户端请求：指客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端套接字的地址和端口号，然后就向服务器端套接字提出连接请求。
3。连接确认：当服务器端套接字监听到或者说接收到客户端套接字的连接请求时，就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述发给客户端，一旦客户端确认了此描述，双方就正式建立连接。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。
三。HTTP链接的特点
HTTP协议即超文本传送协议(Hypertext Transfer Protocol )，是Web联网的基础，也是手机联网常用的协议之一，HTTP协议是建立在TCP协议之上的一种应用。
HTTP连接最显著的特点是客户端发送的每次请求都需要服务器回送响应，在请求结束后，会主动释放连接。从建立连接到关闭连接的过程称为“一次连接”。
四。TCP和UDP的区别
1。TCP是面向链接的，虽然说网络的不安全不稳定特性决定了多少次握手都不能保证连接的可靠性，但TCP的三次握手在最低限度上（实际上也很大程度上保证了）保证了连接的可靠性；而UDP不是面向连接的，UDP传送数据前并不与对方建立连接，对接收到的数据也不发送确认信号，发送端不知道数据是否会正确接收，当然也不用重发，所以说UDP是无连接的、不可靠的一种数据传输协议。
tcp协议和udp协议的差别
是否连接面向连接面向非连接
传输可靠性可靠不可靠
应用场合传输大量数据少量数据
速度慢快
http的常用方式:get,post
app的年龄设置太低 -> 改了年龄⋯
app里有实物奖励 -> 免责声明,和苹果无关⋯
app描述里提了后续版本的功能的字样 -> 删除⋯
app有打分的功能 -> 有reject的,也有通过的⋯
app需要使用location,没有提示用户 -> 加了提示,允许用户拒绝⋯
第一步: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
4、php文件要喝pem文件放在同一目录。
5、除了alert sound和badge之外,json串里还可以包含自定义信息。
6、推送的信息最大255字节 7、推送的信息受网络影响较大,有可能造成延迟甚至丢失,重要信息的传递不应该使用push通知,应该有专门的 后台接口。
开放:
XMPP网络的架构和电子邮件十分相像;XMPP核心协议通信方式是先创建一个stream,XMPP以TCP传递XML数据流,没有 中央主服务器。 任何人都可以运行自己的XMPP服务器,使个人及组织能够掌控他们的实时传讯体验。
安全:
任何XMPP协议的服务器可以独立于公众XMPP网络(例如在企业内部网络中),而使用SASL及TLS等技术的可靠安全性,已自 带于核心XMPP技术规格中。
可扩展:
XML 命名空间的威力可使任何人在核心协议的基础上建造定制化的功能;为了维持通透性,常见的扩展由XMPP标准基金会 。 弹性佳:
XMPP除了可用在实时通信的应用程序,还能用在网络管理、内容供稿、协同工具、文件共享、游戏、远程系统监控等。 多样性:
用XMPP协议来建造及布署实时应用程序及服务的公司及开放源代码计划分布在各种领域;用XMPP技术开发软件,资源及支持的 来源是多样的,使得使你不会陷于被“绑架”的困境。
缺点
数据负载太重:
随着通常超过70%的XMPP协议的服务器的数据流量的存在和近60%的被重复转发,XMPP协议目前拥有一个大型架空中存在的 数据提供给多个收件人。 新的议定书正在研究,以减轻这一问题。
没有二进制数据:
XMPP协议的方式被编码为一个单一的长的XML文件,因此无法提供修改二进制数据。 因此, 文件传输协议一样使用外部的 HTTP。 如果不可避免,XMPP协议还提供了带编码的文件传输的所有数据使用的Base64 。 至于其他二进制数据加密会话 (encrypted conversations)或图形图标(graphic icons)以嵌入式使用相同的方法。
//—————————————————————————————————————————————
//给block赋值的特点，类型一致，以^托字符 插入箭头开头 函数的定义（实现），去掉函数名；后面是赋的值；无法调用；
// int x= block1(10,20); //接收一下
int y= block2(10,20);
NSLog(@"%d",y);
block2 =^int(int x,int y)//返回值int 可以删除，
{
return x-y;
};
//(BOOL)(^)(NSString *,NSString *) 类型
int(^blockSum)(NSString *str1,NSString *str2)//定义(^)加上函数实现
=^int (NSString *str1,NSString *str2){ //int 可以删除，但必须保证return后面的类型一致；
return [str1 intValue]+[str2 intValue];//intValue把字符串变成字符
};
int result= blockSum(@"100",@"150");
NSLog(@"%d",result);
int(^aa)()=^(){
return 10;
};
// ^后面的()可以删除，当block后面没有参数的时候，可以吧（）也省略掉；
NSLog(@"%d",aa());
void(^bb)()=^{NSLog(@"hello lanou");}; //分号不能少;
bb();//调用^后面的
// NSString *str1=@"adsj";
// NSString *str2=@"sada";字符串比较
NSComparisonResult (^aaa)(NSString *str1,NSString*str2 )=^(NSString *str1,NSString *str2){
return [str1 compare:str2];//字符串比较函数campare 等号后面^后面()不能漏
};
NSLog(@"%ld",aaa(@"hao",@"jian"));
//block可以使用外部变量,但是不能修改;如果想改值用__block,两个下划线
__block int m=100;//static修饰符
int (^block)(int,int)=^(int x,int y){
a=100;//可以修改外部变量;
return x+y+(++m)-a;
};
NSLog(@"%d",block(20,30));
//__block相当于static,静态区,一直存在,直到程序结束.
- - (void)testAccessVariable
- {
- NSInteger outsideVariable = 10;
- //__block NSInteger outsideVariable = 10;
- NSMutableArray * outsideArray = [[NSMutableArray alloc] init];
- void (^blockObject)(void) = ^(void){
- NSInteger insideVariable = 20;
- KSLog(@" > member variable = %d", self.memberVariable);
- KSLog(@" > outside variable = %d", outsideVariable);
- KSLog(@" > inside variable = %d", insideVariable);
- [outsideArray addObject:@"AddedInsideBlock"];
- };
- outsideVariable = 30;
- self.memberVariable = 30;
- blockObject();
- KSLog(@" > %d items in outsideArray", [outsideArray count]);
- }
- > member variable = 30
- > outside variable = 10
- > inside variable = 20
- > 1 items in outsideArray
- typedef NSString* (^IntToStringConverter)(id self, NSInteger paramInteger);
- - (NSString *) convertIntToString:(NSInteger)paramInteger
- usingBlockObject:(IntToStringConverter)paramBlockObject
- {
- return paramBlockObject(self, paramInteger);
- }
- typedef NSString* (^IntToStringInlineConverter)(NSInteger paramInteger);
- - (NSString *) convertIntToStringInline:(NSInteger)paramInteger
- usingBlockObject:(IntToStringInlineConverter)paramBlockObject
- {
- return paramBlockObject(paramInteger);
- }
- IntToStringConverter independentBlockObject = ^(id self, NSInteger paramInteger) {
- KSLog(@" >> self %@, memberVariable %d", self, [self memberVariable]);
- NSString *result = [NSString stringWithFormat:@"%d", paramInteger];
- KSLog(@" >> independentBlockObject %@", result);
- return result;
- };
- - (void)testAccessSelf
- {
- // Independent
- //
- [self convertIntToString:20 usingBlockObject:independentBlockObject];
- // Inline
- //
- IntToStringInlineConverter inlineBlockObject = ^(NSInteger paramInteger) {
- KSLog(@" >> self %@, memberVariable %d", self, self.memberVariable);
- NSString *result = [NSString stringWithFormat:@"%d", paramInteger];
- KSLog(@" >> inlineBlockObject %@", result);
- return result;
- };
- [self convertIntToStringInline:20 usingBlockObject:inlineBlockObject];
- }
- @interface KSViewController ()
- {
- id _observer;
- }
- @end
- @implementation KSViewController
- - (void)viewDidLoad
- {
- [super viewDidLoad];
- // Do any additional setup after loading the view, typically from a nib.
- KSTester * tester = [[KSTester alloc] init];
- [tester run];
- _observer = [[NSNotificationCenter defaultCenter]
- addObserverForName:@"TestNotificationKey"
- object:nil queue:nil usingBlock:^(NSNotification *n) {
- NSLog(@"%@", self);
- }];
- }
- - (void)dealloc
- {
- if (_observer) {
- [[NSNotificationCenter defaultCenter] removeObserver:_observer];
- }
- }
- __weak KSViewController * wself = self;
- _observer = [[NSNotificationCenter defaultCenter]
- addObserverForName:@"TestNotificationKey"
- object:nil queue:nil usingBlock:^(NSNotification *n) {
- KSViewController * sself = wself;
- if (sself) {
- NSLog(@"%@", sself);
- }
- else {
- NSLog(@"
dealloc before we could run this code."); - }
- }];
- - (id) getBlockArray
- {
- int val = 10;
- return [[NSArray alloc] initWithObjects:
- ^{ KSLog(@" > block 0:%d", val); }, // block on the stack
- ^{ KSLog(@" > block 1:%d", val); }, // block on the stack
- nil];
- // return [[NSArray alloc] initWithObjects:
- // [^{ KSLog(@" > block 0:%d", val); } copy], // block copy to heap
- // [^{ KSLog(@" > block 1:%d", val); } copy], // block copy to heap
- // nil];
- }
- - (void)testManageBlockMemory
- {
- id obj = [self getBlockArray];
- typedef void (^BlockType)(void);
- BlockType blockObject = (BlockType)[obj objectAtIndex:0];
- blockObject();
- }