Objective－C
動態綁定-運行時肯定要調用的方法
Gategory類別的做用？ php
分別描述類別(categories)和延展(extensions)是什麼?以及二者的區別?繼承和類別在實現中有何區html
別?爲何Category只能爲對象添加方法,卻不能添加成員變量?java
類別:在沒有原類.m文件的基礎上,給該類添加方法; 延展:一種特殊形式的類別,主要在一個類的.m文件裏聲明和實現延展的做用,就是給某類添加私有方法或是私有變量。 兩個的區別:延展能夠添加屬性而且它添加的方法是必需要實現的。延展能夠認爲是一個私有的類目。 繼承和類別在實現中的區別:類別能夠在不獲悉,不改變原來代碼的狀況下往裏面添加新的方法,只能添加,不能刪除修 改。而且若是類別和原來類中的方法產生名稱衝突,則類別將覆蓋原來的方法,由於類別具備更高的優先級。 Category只能爲對象添加方法,卻不能添加成員變量的緣由:若是能夠添加成員變量,添加的成員變量沒有辦法初始 化----這是語言規則node
– (void)thisIsAnInstanceMethod;
@end
@private能夠用來修飾私有變量
在Objective‐C中，全部實例變量默認都是私有的，全部實例方法默認都是公有的ios
if ([device respondsToSelector:@selector(isMultitaskingSupported)])
目標-動做機制 目標是動做消息的接收者。一個控件,或者更爲常見的是它的單元,以插座變量的形式保有其動做消息的目標。c++
那麼先讓咱們來看一看下邊數組類型的轉換程序員
一、不可變對象→可變對象的轉換：web
NSArray *array1= [NSArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];objective-c
NSMutableArray *str2=[array1 mutableCopy];sql
二、可變對象→不可變對象的轉換：
NSMutableArray *array2 = [NSMutableArray arrayWithObjects:@"aa",@"bb",@"cc",@"dd",nil];
NSArray *array1=[ array2 Copy];
三、可變對象→可變對象的轉換（不一樣指針變量指向不一樣的內存地址）：
NSMutableArray *array1= [NSMutableArray arrayWithObjects:@"a",@"b",@"c",@"d",nil];
NSMutableArray *str2=[array1 mutableCopy];
經過上邊的兩個例子，咱們可輕鬆的將一個對象在可變和不可變之間轉換，而且這裏不用考慮內存使用原則（即引用計數的問題）。沒錯，這就是深拷貝的魅力了。
四、同類型對象之間的指針複製（不一樣指針變量指向同一塊內存地址）：
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
好比:本地化應用程序名稱
(一、選中工程,Info—Localizations點擊「+」添加要國際化的語言。 (二、在InfoPlist.strings右邊會多出一個三角形,點擊展開可看到InfoPlish.strings(english)和
InfoPlish.strings(chinese)兩個版本的文件; (三、在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是銷燬一個對象。
1六、重寫一個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的使用原則：
1、KVC(key-value-coding)
一、只針對類屬性，設置鍵值對
二、設置setValue: forKey:，即forKey只能爲類屬性
三、取值valueForKey
2、KVO(key-value-observing)被觀察者的屬性發生改變時，通知觀察者
一、利用KVC對類屬性進行設置
二、註冊observing對象addObserver:forKeyPath:options:context:
三、觀察者類必須重寫方法 observeValueForKeyPath:ofObject:change:context:
四、應用，MVC模型中，數據庫（dataModal）發生變化時，引發view改變，用這種方式實現很是方便
優勢：
1.設置值,會查找屬性的getter（valueForKey）和setter（setValueForKey）方法，而後查找其名字的實例變量。
2.支持指定鍵路徑，就像文件系統的路徑同樣。好比：car.emgine.horespower
3.總體操做，好比：給一個汽車的輪子發送kvc消息，因爲汽車有4個輪子，調用代碼(valueForKeyPath:@「tires.pressure」)後會返回一個數組（包含4個數據）。
4.快速運算:能夠引用一些運算符來進行一些計算。如:cars.@count,cars.@avg.mileage (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之間能夠經過委託來傳值！
下面這個例子委託有兩類：
一、一個視圖類對象的代理對象爲父視圖，子視圖用代理實現讓父視圖顯示別的子視圖
二、同一父視圖下的一個子視圖爲另外一個子視圖的代理對象，讓另外一個子視圖改變自身背景色爲給定的顏色
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
規範格式以下：
@protocol TransparendValueDelegate;
@interface A：UIView
id< TransparendValueDelegate > m_dTransparendValueDelegate;
@property(nomatic, retain) id m_dTransparendValueDelegate;
@end
//代理協議的聲明
@protocol TransparendValueDelegat<NSObject>
{
-(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.
完整的單例：
一、爲單例對象實現一個靜態實例，並初始化，而後設置成nil，
二、實現一個實例構造方法檢查上面聲明的靜態實例是否爲nil，若是是則新建並返回一個本類的實例，
三、重寫allocWithZone方法，用來保證其餘人直接使用alloc和init試圖得到一個新實力的時候不產生一個新實例，
四、適當實現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座標系統中的位置和大小。（參照點是，父親的座標系統）
一、做爲容器,包含app所要顯示的全部視圖
二、傳遞觸摸消息到程序中view和其餘對象
三、與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有三種主要方法:一、NSThread。二、NSOperation。三、GCD。 (4)解決方案:使用鎖:鎖是線程編程同步工具的基礎。鎖可讓你很容易保護代碼中一大塊區域以便你能夠確保代碼的正 確性。使用POSIX互斥鎖;使用NSLock類;使用@synchronized指令等。
(5)回到主線程的方法: dispatch_async(dispatch_get_main_queue(), ^{ });
做用:主線程是顯示UI界面,子線程多數是進行數據處理
Core Data不是一個關係型數據庫,也不是關係型數據庫管理系統(RDBMS)。雖然Core Dta支持SQLite做爲一種存儲類型, 但它不能使用任意的SQLite數據庫。Core Data在使用的過程種本身建立這個數據庫。Core Data支持對1、對多的關係。
第四種：文件寫入磁盤
NSUserDefaults類的使用和NSKeyedArchiver有不少相似之處，可是查看NSUserDefaults的定義能夠看出，NSUserDefaults直接繼承自NSObject而NSKeyedArchiver 繼承自NSCoder。這意味着NSKeyedArchiver其實是個歸檔持久化的類，也就能夠使用NSCoder類的［encodeObject: (id)objv forKey:(NSString *)key］方法來對數據進行持久化存儲
在代碼中，你再也不使用存取方法和修改方法，而是使用鍵值對編碼來設置屬性或者減縮他們的值
那麼這些託管對象的活動區域在哪 ？ 他們位於所謂的持久庫中，默認狀況下，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都使用結構化方法來標記數據
二、DOM 以及廣義的基於樹的處理具備幾個優勢。首先,因爲樹在內存中是持久的,所以能夠修改它以便應用程序能對數 據和結構做出更改。它還能夠在任什麼時候候在樹中上下 導航,而不是像 SAX 那樣是一次性的處理。DOM 使用起來也要簡單 得多。另外一方面,在內存中構造這樣的樹涉及大量的開銷。大型文件徹底佔用系統內存容量的狀況並不鮮見。此外,建立一 棵 DOM 樹多是一個緩慢的過程。
三、選擇 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、打開、關閉），這些函數咱們在後面進行介紹。
咱們在傳輸數據時，能夠只使用（傳輸層）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)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)生成 編譯程序 用的描述文件(網頁裏進行) 二、向APNS註冊push服務(UIApplication的registerForRemoteNotificationTypes:方法)
第二步 獲取APNS分配的DeviceToken(64位16進制串)
- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken
第三步 把DeviceToken發送給本身的後臺服務器,服務器記錄每臺設備的DeviceToken以便往後推送信息給客 戶端。(須要有一個網絡接口,讓客戶端發送DeviceToken)
第四步 服務器推送信息給客戶端 一、服務器除了須要有客戶端的DeviceToken以外,還要有push證書,對push的內容進行簽名。(蘋果爲了防 止 惡意向客戶端(好比DeviceToken泄露了)發送消息,每次推送消息,都須要證書進行簽名,從而避免黑客惡 意攻擊用戶手機。) 二、若是你的服務器是java寫的,能夠直接使用鑰匙串導出的p12文件(證書和密鑰一塊兒導出)。若是你的服務器 是php寫的,由於php語言不支持p12文件類型,須要轉換爲pem文件。
三、將p12轉換爲pem文件:終端 先找到你p12所在的目錄 openssl pkcs12 -in CertificateName.p12 - outCertificateName.pem -nodes
四、服務器發送信息給APNS,APNS自動將信息推送給客戶端
第五步 客戶端處理收到的信息
- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo
四、php文件要喝pem文件放在同一目錄。
五、除了alert sound和badge以外,json串裏還能夠包含自定義信息。
六、推送的信息最大255字節 七、推送的信息受網絡影響較大,有可能形成延遲甚至丟失,重要信息的傳遞不該該使用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(@"<self> 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();
- }
- 1. Objective-C：swift、objective-c、C++、C混合編程
- 2. Objective-C
- 3. Objective-C Reflection（Objective-C 反射機制）
- 4. Objective-C語言（一）熟悉Objective-C
- 5. 【Objective-C】Objective-C語言的動態性
- 6. Objective-C教程：Objective-C類的定義
- 7. 從 C++ 到Objective-C
- 8. From C++ to Objective-C
- 9. 從 C++ 到 Objective-C
- 10. 從C++到objective-c
- 更多相關文章...
- • SQLite - C/C++ - SQLite教程
- • C# 集合（Collection） - C#教程
- • C# 中 foreach 遍歷的用法
- • 委託模式
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 跳槽面試的幾個實用小技巧，不妨看看！
- 2. Mac實用技巧 |如何使用Mac系統中自帶的預覽工具將圖片變成黑白色?
- 3. Mac實用技巧 |如何使用Mac系統中自帶的預覽工具將圖片變成黑白色?
- 4. 如何使用Mac系統中自帶的預覽工具將圖片變成黑白色?
- 5. Mac OS非兼容Windows軟件運行解決方案——「以VMware & Microsoft Access爲例「
- 6. 封裝 pyinstaller -F -i b.ico excel.py
- 7. 數據庫作業三ER圖待完善
- 8. nvm安裝使用低版本node.js(非命令安裝)
- 9. 如何快速轉換圖片格式
- 10. 將表格內容分條轉換爲若干文檔