iOS知識點匯總復習
@
看到這個關鍵字，我們就應該想到，這是Object-C對Ｃ語言的擴展，例如@interface XXX。
@interface
聲明類
@implementation
實現類
@protocol
聲明協議
@optional
與@protocol配合使用，說明協議中的某個或者某幾個方法可以不實現
@required
與@protocol配合使用，說明協議中的某個方法或者某幾個方法必須實現
@end
與@interface ,@implementation,@protocol配合使用，代表聲明或者實現結束
@encode
@encode為編譯器宏，它可以將類型轉換為相應的字符串。
id
id是指向Objective-C類對象的指針，它可以聲明為任何類對象的指針，當在Objective-C中使用id時，編譯器會假定你知道，id指向哪個類的對象。與void*是不同的是，void*編譯器不知道也不假定指向任何類型的指針。
nil
定義為一個常量，如果一個指針的值為nil,代表這個指針沒有指向任何對象。
self
在Objective-C中，關鍵字self與c++中this是同一概念，就是類對象自身的地址，通過self可以調用自己的實例變量和方法
Super
當子類需要調用父類的方法時，會用到Super關鍵字. Super指向的是父類的指針，子類重寫父類的方法時，調用父類的方法是一個比較好的習 慣。因為 當我們不知道父類在該方法中實現的功能時，如果不調用父類的方法，有可能我們重寫的方法會失去該功能，這是我們不願意看到的情況。
NSNull
NSNull是沒有的意思，如果一個字典的值為NSNull,那說明與該值對應的Key是沒有值的，例如Key為address，說明與address對應的是值是沒有。
self super class public protected private id
[self class] [super class] selector
objective-c runtime reference
標准用法
self = [super init]
new
1 Objective-C有一個特性，就是可以把類當成對象來發送消息，這種用法通常用於新建對像時，例如 XXX *object = [XXX new];
類方法 +
如果想聲明屬於類而不屬於類對象的方法，用+。＋用來修飾類的方法，使用+修飾的類方法，是整個類的方法，不屬於哪一個類對象，這與C++中的static在類中使用的概念一樣，
%@
在NSLog中，使用%@表示要調用對象的description方法。
概念
類
是一種結構，它表示對象的類型，就像int與 char 一樣，也可以聲明類的變量(對像)
實例化
為類的對象分配內存和初始化，達到可以使用該 類對象的目的。
對象(實例)
類的實例化後的產物
消息
在Object-C中，類的對象執行的操作，是通過給該類或者該類對象發送消息實現，如：［object func］；就是給object對象發送 func消息，類似C++中的方法調用。給object對象發送func消息後，object對象查詢所屬類的func方法執行。
方法調度
當向一個對象發送消息時(調用方法)，這個方法是怎麼被調用的呢？這就依賴於方法高度程序，方法調度程序查找的方法如下：
在本類的方法中，找被調用的方法，如果找到了，就調用，如果找不到被沿著繼承路徑去查找，從哪個類找到，就調用哪個類的方法，如果到最根上的類還是沒有找到，那編譯就會出錯。
繼承與復合
在Objective-C中支持繼承，但只是支持單一繼承(有且只有一個父類有)，如果想使用多繼承的特性，可以使用分類和協議技術。
繼承是is-a,復合是has-a。復合是通過包含指向對象的指針實現的，嚴格意義上講，復合是針對於對象間來說，對於基本數據類型來說，它們被認為是對象的一部分。
裝箱與拆箱
由於NSArray,NSDirectory等類不能直接存儲基本數據類型，所以要想在NSArray＼NSDirectory中使用基本數據類型，就得使用裝箱與拆箱。
在Objective-C中，可以使用NSNumber和NSValue來實現對數據類型的包裝，NSNumber可以實現對基本數據類型的包裝，NSValue可以實現對任意類型數據的包裝。
將基本類型封裝成對象叫裝箱，從封裝的對象中提取基本類型叫拆箱(取消裝箱)，其它語言如Java原生支持裝箱與拆箱，Ojbective-C不支持自動裝箱與拆箱，如果需要得需要自己來實現裝箱與拆箱。
存取方法
在使用類對象的實例變量(成員數據)時，不要直接使用對象中的實例，要使用存以方法來獲取或者修改實例，既setter和getter,在 Cocoa中， 存取方法有命名習慣，我們得符合這種習慣，以便於與其它團隊成員合作。setter方法是修改或者設置實例值，命名習慣為set+實例名，例有一個類有 path實例變量，那setter命名為setPath,getter命名為Path,為什麼不是getPath,因為get在Cocoa中有特殊的含 義，這個含義就是帶有get的方法就意味著這個方法通過形參指針(傳入函數的參數指針)來返回值。我們要遵守這個命名習慣或者說規則。
在Objective-C 2.0中加入了@property和@synthesize來代替setter和getter，這兩個關鍵字為編譯器指令。還有點表達式，存取類成員的值時，可以使用點表達式。
Object.attribute,當點表達式在=號左邊時，調用的是setter方法，在=號右邊時，調用的是getter方法。
@property 語法為:@property (參數) 類型 變量名.
在這裡主要說明一下參數.
參數分為三種：
第一種:讀寫屬性包括(readonly/readwrite/)
第二種:setter屬性(assign,copy,retain),assign是簡單的賦值，copy是釋放舊成員變量，並新分配內存地址給成 員 變量，將傳入參數內容復制一份，給成員變量。retain是將傳入 參數引用計數加1，然後將原有的成員變量釋放，在將成員變量指向該傳入參數。
第三種:與多線程有關(atomic,nonatomic).當使用多線程時，使用atomic,在不使用多線程時使用nonatomic
對象創建與初始化
在Objective-C中創建對象有兩種方法，一種是[類 new];另一種是[[類 alloc] init],這兩種方法是等價的，但按慣例來講，使用[[類 alloc] init];
alloc操作是為對象分配內存空間，並將對象的數據成員都初始，int 為0，BOOL 為NO, float 為0.0等。
初始化，默認的初始化函數為init,init返回值為id,為什麼回返回id呢，因為要實現鏈式表達式，在Objective-C中叫嵌套調用。
為什麼要嵌套調用？？因為初始化方法init返回值可能與alloc返回的對象不是同一個？為什麼會發生這種情況？基於類簇的初始化，因為init可以接受參數，在init內部有可能根據不同的參數來返回不同種類型的對象，所以最會發生上面說的情況。
在初始化時，建議使用if (self = [super init])
便利初始化
當一個類需要根據不同的情況來初始化數據成員時，就需要便利初始化函數，與init初始化不同的是，便利初始化函數有參數，參數個數可以有1到Ｎ個，Ｎ是類數據成員個數。
指定初始化函數：什麼是指定初始化函數？在類中，某個初始化函數會被指定為指定的初始化函數，確定指定初始化函數的規則是初始化函數中，參數最多的為指定初始化函數，其它未被指定為指定初始化函數的初始化函數要調用指定初始化函數來實現。對於該類的子類也是一樣，只要重寫或者直接使用父類的指定初始化函數。上述文字有些繞，來個例子吧
@interface A{
int x;
int y;
}
-(id) init;
-(id) initWithX:(int) xValue;
-(id) initWithY:(int) yValue;
-(id) initWithXY:(int) xValue
yVal:(int) yValue;
@end
這裡initWithXY被確定為指定初始化函數。
-(id) initWithXY:(int) xValue
yVal:(int) yValue{
if (self = [super init]){
x = xValue;
y = yValue;
}
return self;
}
-(id) init{
if (self = self initWithXY:10
yVal:20){
}
return self;
}
.......
@interface B: A{
int z;
}
-(jd) initWithXY......;
@end
@implementation B
-(id) initWithXY:(int) xValue
yVal:(int) yValue{
if (self = [super initWithXY:10
yVal=20]){
z= 40;
}
return self;
}
@end
自動釋放池
內存管理是軟件代碼中的重中之重，內存管理的好壞，直接影響著軟件的穩定性。在Cocoa中，有自動釋放池，這類似於C++中的智能指針。
NSObject有一個方法是autorelease，當一個對象調用這個方法時，就會將這個對象放入到自動釋放池中。
drain,該方法是清空自動釋放池，不是銷毀它。drain方法只適用於Mac OS X 10.4以上的版本，在我們寫的代碼中要使用release，release適用於所有版本。
自動釋放池是以棧的方式實現，當創建一個自動釋放池A時，A被壓入棧頂，這時將接入autorelease消息的對象放入A自動釋放池，這時創建一 個新的 B自動釋放池，B被壓入棧頂，創建完成後刪除B,這個接收autorelease消息的對象依然存在，因為A自動釋放池依然存在。
引用計數
每個對象都有一個與之相應的整數，稱它為引用計數，當該引用計數為0時，Objective-C自動向該對象發送dealloc,以銷毀該對向，與該引用計數相關的方法(消息)有下面幾個
1 增加引用計數：通過alloc,new,copy創建一個對象時，該對象的引用計數加1(其實就是1，因為之前為0)
2 增加引用計數: retain
3 減少引用計數: release
局部分配內存(臨時對象):
1 如果使用alloc,new,copy創建對象，則需要主動調用對象的release方法
2 如果使用非alloc,new,copy創建對象，我們認為該對象引用計數為1，並已經加入了自動釋放池，我們不需要主動的調用對象的release方法。
擁有對象(在類中以成員的方法存在):
1 如果使用alloc,new,copy創建對象，則需要在dealloc方法中，釋放該對象
2 如果使用非alloc,new,copy創建對象，則在擁有該對象時，保留該對象(執行retain方法)，在dealloc方法中，釋放該對象。
dealloc
當對象的引用計數為0時，Objective-C會自動發送對象的dealloc消息(自動調用對象的dealloc方法，類似於C++的析構函數)，所以我們可以自己重寫dealloc方法，來實現類裡的對其它使用資源的釋放工作。
注意：不要直接在代碼中顯示調用dealloc方法。
垃圾回收
在Objective-C 2.0中引入了垃圾回收機制(自動管理內存)，在工程設置裡設置Objective-C Garbage Collection為Required[-fobjc-gc-only]就可以使用垃圾回收機制。
啟用垃圾回收機制後，通常的內存管理命令都變成了空操作指令，不執行任何操作。
Objective-C的垃圾回收機制是一種繼承性的垃圾回收器，垃圾回收器定期檢查變量和對象以及他們之間的指針，當發現沒有任何變量指向對象時，就將該對象視為被丟棄的垃圾。所以在不在使用一個對象時，將指針他的指針設置為nil,這時垃圾回收器就會清理該對象。
注意：如果開發iPhone軟件，則不能使用垃圾回收。在編寫iPhone軟件時，Apple公司建議不要在自己的代碼中使用autorelease方法，並且不要使用創建自動釋放對象的函數。
類別
什麼是類別？類別是一種為現有類添加新方法的方式。
為什麼使用類別或者說使用類別的目的是什麼？有以下三點：
第一，可以將類的實現分散到多個不同的文件或多個不同的框架中。
如果一個類需要實現很多個方法，我們可以將方法分類，把分好的類形成類別，可以有效的管理和駕馭代碼。
第二，創建對私有方法的前向引用。
第三，向對象添加非正式協議。
委托
委托的意思就是你自己想做某事，你自己不做，你委托給別人做。
在Ojbective-C中，實現委托是通過類別(或非正式協議)或者協議來實現。
舉個例子：Apple要生產iPhone,Apple自己不生產(種種原因，其中之一就是在中國生產成本低，他們賺的銀子多),Apple委托富士 康來生 產,本來富士康原來不生產iPhone,現在要生產了,所以他得自己加一個生產iPhone的生產線(類別，增加生產iPhone方法)，這就是通過類別 來實現委托。下面用代碼來說明這個例子。
....
Apple *apple = [[Apple alloc ] init];
Foxconn *fox = [[Foxconn alloc] init];
[apple setDelegate:fox];
[apple produceIPhone];
........
@implementation Apple
-(...) setDelegate:(id) x{
delegate = x; //! 將委托的生產對象指定為x
}
-(...) produceIPhone{
[delegate produceIPhone]; //! 委托對象生產iPhone
}
@interface Foxconn : NSObject
...
@end
@interface NSObject(ProduceIPhone) //! Foxconn之前就可以生產其它產品，有過聲明和定義
-(...) produceIPhone //! 增加生產iPhone能力
@end
@implementation NSObject(ProduceIPhone)
//! 生產iPhone
-(...) produceIPhone{
......
}
@end
非正式協議
創建一個NSObject的類別， 稱為創建一個非正式協議。為什麼叫非正式協議呢?
也就是說可以實現，也可以不實現被委托的任務。
拿上面的例子來說，Apple要求Foxconn除了能生產iPhone外，還有一個要求是在一定時間內完成.由於雙方沒有簽合同，所以時間要求和生產要求規格都是非正式協議
選擇器
選擇器就是一個方法的名稱。選擇器是在Objective-C運行時使用的編碼方式，以實現快速查找。可以使用@selector預編譯指令，獲取 選擇器 @selector(方法名)。NSObject提供了一個方法respondsToSelector:的方法，來訪問對象是否有該方法(響應該消息)。
拿上面的Apple請Foxconn生產iPhone為例，Apple怎麼知道Foxconn有沒有生產iPhone的能力呢?Apple就通過 respondsToSelector方法詢問Foxconn，是否可以生產iPhone(是否可以響應produceIPhone)，詢問結果是可以， 那Apple就委托Foxconn生產，Foxconn就生產出來了人們比較喜歡的iPhone產品。
正式協議
與非正式協議比較而言，在Ojbective-C中，正式協議規定的所有方法必須實現。在Ojbective-C2.0中，Apple又增加了兩個關鍵字，協議中的方法也可以不完全實現，是哪個關鍵字見關鍵字部份的@optional,@required。
正式協議聲明如下:
@protocol XXX
-(...) func1;
-(...) func2;
@end
使用協議:
@interface Object : NSObject //! Object從NSObject派生，並遵循XXX協議，要實現func1,func2函數。
...
@end
習慣用法
分配內存和初始化
self = [super init];
對象間交互
在Objective-C中，所有對象間的交互都是通過指針實現。
快速枚舉
for (Type *p in array)
注意:
Objective-C不支持多繼承
objective-c只不過是擁有一些附加特性的C語言。本質上就是C語言
1.C語言使用#include通知編譯器應在頭文件中查詢定義。objective-c也可以使用#include來實現這個目的，但你永遠不可能這麼做，你會用#import，它是GCC編譯器提供的，#import可以保證頭文件只被包含一次。
xcode會使用預編譯頭文件（一種經過壓縮的，摘要形式的頭文件），在通過#import導入這種文件時，加載速度會非常快。
2.什麼是框架
框架是一種聚集在一個單元的部件集合，包含頭文件，庫，圖像，聲音文件等。蘋果公司將cocoa，Carbon，QuickTime和OpenGL 等技術 作為框架集提供。cocoa的組成部分有Foundation和Application Kit框架。還有一個支持框架的套件，包含 Core Animation和Core Image，這為Cocoa增添了多種精彩的功能。
每個框架都是一個重要的技術集合，通常包含數十個甚至上百個頭文件。每個框架都有一個主頭文件，它包含了所有框架的各個頭文件。通過使用#import導入主頭文件，可以使用所有框架的特性。
3.Foundation框架處理的是用戶界面之下的層（layer）中得特性，例如數據結構和通信機制。
4.NS前綴
NS這個前綴告訴你函數來自cocoa而不是其他工具包。
兩個不同事物使用相同標示符時會導致名稱沖突，而前綴可以預防這個大問題。
5.BOOL類型
objective-c中得BOOL實際上是一種對帶符號的字符類型（signed char）的定義。它使用8位存儲空間，YES為1，NO為0.
6.間接
不在代碼中直接使用某個值，而是使用指向該值的指針。另一個意思是，讓別的類來完成本類的工作。
例子：
1.循環次數的變量。變量與間接
2.使用從文件讀取。文件與間接
在OOP（面向對象編程）中，間接十分重要。OOP使用間接來獲取數據，OOP真正的革命性就是它在調用代碼中使用間接。比如在調用函數時，不是直接調用，而是間接調用。
7.過程式程序與OOP的區別
過程式程序建立在函數之上，數據為函數服務。面向對象編程從相反的角度來看待問題。它以程序的數據為中心，函數為數據服務。在OOP中，不在重點關注程序中得函數，而是專注與數據。
8.id
id是一種泛型，用於表示任何種類的對象。
9.OOP中得一些術語
類：類是一種結構，它表示對象的類型。對象引用類來獲取和本身有關的各種信息，特別是運行什麼代碼來處理每種操作。
對象：對象是一種結構，它包含值和指向其類的隱藏指針。
實例：實例是“對象”的另一種稱呼。
消息：消息是對象可以執行的操作，用於通知對象去做什麼。
方法：方法是為響應消息而運行的代碼。根據對象的類，消息可以調用不同的方法。
方法調度程序：是objective-c使用的一種機制，用於推測執行什麼方法以響應某個特定的消息。
接口：接口是對象的類應該提供的特性的描述。接口不提供實現細節。
實現：實現是使接口正常工作的代碼。
10.中綴符
objective-c有一種名為中綴符的語法技術。方法的名稱及其參數都是合在一起的。例如： [trxtThing setStringValue:@"Hello there" color:kBlueColor]; 中 setStringValue: 和 color:實際上是參數的名稱（實際上是方法名稱的一部分）。使代碼可讀性更強，更容易理解參數的用途。
11.先行短線
-(void)draw;
前面的短線表明這是objective-c方法的生命。這是一種區分函數原型與方法聲明的方式，函數原型中沒有先行短線。-代表是實例方法。+代表是類方法。
12.@interface
創建某個特定類的對象之前，objective-c編譯器需要一些有關該類的信息。他必須知道對象的數據成員和它提供的特性可以使用@interface指令把這種信息傳遞給編譯器。用於定義類的公共接口。
13.@implementation
是一個編譯器指令，表明你將為某個類提供代碼。類名出現在@implementation之後。該行的結尾處沒有分號。因為在objective-c編譯器指令後不必使用分號。
@interface和@implementation間的參數名不同是正確的。
在@interface中沒有聲明卻在@implementation中實現的方法是私有方法。
14.實例化
創建對象的過程叫做實例化。實例化對象時，需要分配內存，然後這些內存被初始化並保存一些有用的默認值，這些值不同於你在獲得新分配內存時得到的隨機值。內存分配和初始化完成後，就創建了一個新的對象實例。
15.繼承
創建一個新類時，通常需要定義新類以區別於其他類以及現有類。使用繼承可以定義一個具有父類所有功能的新類，它繼承了父類的這些功能。
objective-c沒有多繼承。
創建一個新類時，其對象首先從自身的超類中繼承實例變量，然後添加他們自己的實例變量。
超類
父類
子類
孩子類
重寫
方法調度:objective-c的方法調度程序將子當前類中搜索響應的方法。如果調度程序無法在接受消息的對象類中找到響應的方法，它就會在該類的超類中進行查找。順著繼承鏈找到下一個超類進行查找，直到NSObject類中也沒有該方法，則會出現運行時錯誤。
16.復合
對象引用其他對象時，可以利用其他對象提供的特性，這就是復合。
17.UML
UML是一種用圖表表示類，類的內容以及他們之間關系的常見方法。
18.多態
使用更具體種類的對象（子類對象）代替一般類型（父類），這種能力稱為多態性。
19.self
是一個指向接收消息的對象的指針。指向第一個實例變量isa。因為objective-c編譯器已經看到了所有這些類的@interface聲明，因此，它能直到對象中實力變量的布局，通過這些重要的信息，編譯器可以產生代碼並查找任何需要的實例變量。
基地址加偏移：編譯器使用“基地址加偏移”機制實現奇妙的功能。給定的對象基地址，是指第一個實例變量的首個字節在內存中得位置，通過在該地址加上偏移地址，編譯器就可以查到其他實例變量的位置。
20.間接尋址方式，直接尋址方式
21.super
objective-c提供某種方式來重寫方法，並且仍然調用超類的實現方式。當需要超類實現自身的功能，同時在前面或者後面執行某些額外的工作時，這種機制非常有用。為了調用繼承方法的實現，需要使用super作為方法調用的目標。
22.cocoa
cocoa實際上是由2個不同的框架組成的：Foundation Kit和 Application Kit。Application Kit包含了所有的用戶接口對象和高級類。
Foundation Kit
23.NSAutoreleasePool
mian()函數創建了(通過alloc)並初始化(通過init)了一個NSAutoreleasePool實例。在mian()函數結尾，這個池被排空。這就是Cocoa內存管理的預覽。
24.NSRange
typedef struct _NSRange {
unsigned int location;
unsigned int length;
}NSRange;
這個結構體用來表示相關事務的范圍，通常是字符串裡的字符范圍或者數組裡的元素范圍。
25.三種賦值方式
1.NSRange range;
range.location = 17;
range.length = 4;
2.C語言的聚合結構賦值機制
NSRange range = {17, 4};
3.Cocoa提供的一個快捷函數NSMakeRange()
NSRange range = NSMakeRange(17, 4);
使用NSMakeRange()的好處是你可以在任何能夠使用函數的地方使用它，例如在方法調用中將其當成參數傳遞。
26.幾何數據類型
1.NSPoint 代表笛卡兒平面中得一個點(x, y).
typedef struct _NSPoint {
float x;
float y;
}NSPoint;
2.NSSize 用來存儲長度和寬度
typedef struct NSSize {
float width;
float height;
}NSSize;
3.NSRect 矩形數據類型，它是由點和大小復合而成
typedef struct _NSRect {
NSPoint origin;
NSSize size;
}NSRect;
27.字符串NSString
stringWithFormat:就是一個工廠方法，它根據你提供的參數創建新對象。
length:長度
isEqualToString:比較字符串內容是否相同
compart:將接受對象和傳遞來的字符串逐個字符的進行比較。返回一個enum數據
NSCaseInsensitiveSearch:不區分大小寫字符。
NSLiteralSearch:進行完全比較，區分大小寫
NSNumericSearch:比較字符串的字符個數，而不是字符值。
-(NSRange)rangeOfString:(NSString *)aString;
返回的range.start為開始位置，range.length為長度。
28.NSMutableString可變字符串。
stringWithCapacity:創建一個新的NSMutableString
字符串的大小並不僅限於所提供的容量，這個容量僅是個最優值。如果要創建一個40mb的字符串。
NSMutableString *str = [NSMutableString stringWithCapacity：42];
appendString接受參數aString，然後將其復制到接收對象的末尾。
appendFormat與stringWithFormat：類似，但它將格式化的字符串附加在接收字符串的末尾，而不是創建新的字符串對象。
29.集合家族
1.NSArray:是一個Cocoa類，用來存儲對象的有序列表。
兩個限制：1.只能存儲objective-c的對象，不能存儲C語言中得基本數據類型。
2.也不能存儲nil。
30.枚舉器，快速枚舉
31.NSDictionary字典
關鍵字及其定義的集合。
32.NSNumber包裝(以對象形式實現)基本數據類型
裝箱：將一個基本類型的數據包裝成對象。
取消裝箱：從對象中提取基本類型的數據。
objective-c不支持自動裝箱。
33.NSValue是NSNumber的父類。
+(NSValue *)valueWithBytes:(const void *)value objCType:(const char *)type;
傳遞的參數是你想要包裝的數值的地址(如一個NSSize或你自己的struct)。通常，得到的是你想要存儲的變量的地址（在C語言中使用操作 符&）。你也可以提供一個用來描述這個數據類型的字符串，通常用來說明struct中實體的類型和大小。你不用自己寫代碼來生成這個字符 串，@encode編譯器指令可以接受數據類型的名稱並為你生成合適的字符串。
NSRect rect = NSMakeRect(1, 2, 30, 40);
NSValue *value;
value = [NSValue valueWithBytes:&rect objCType:@encode(NSRect)];
[array addObject:value];
34.NSNull只有一個方法[NSNull null];
[NSNull null]總是返回一樣的數值，所以你可以使用運算符==將該值與其他值進行比較。
35.單實例架構：只需要一個實例。
查找文件：
例如：NSFileManager *manager;
manager = [NSFileManager defaultManager];
defaultManager可以為我們創建一個屬於我們自己的NSFileManger對象。
NSString *home = [@"~" stringByExpandingTildeInPath];將~替換成當前用戶的主目錄。
NSDirectoryEnumerator *direnum = [manager enumeratorAtPath:home];返回一個 NSDictionaryEnumerator，它是NSEnumerator的子類。每次在這個枚舉器對象中調用nextObject時，都會返回該目 錄中得一個文件的另一個路徑。
36.內存管理
1)對象生命周期
對象的生命周期包括誕生(alloc或者new方法實現)，生存(接受消息和執行操作)，交友(借助方法的組合和參數)以及當他們的生命結束時最終死去(被釋放)。當對象的生命周期結束時，他們的原材料(內存)將被回收以供新的對象使用。
2)引用計數
cocoa采用了一種稱為引用計數的技術，有時候也叫保留計數。每個對象有一個與之相關聯的整數，稱作它的引用計數器或保留計數器。當某段代碼需要 訪問一 個對象時，該代碼將該對象的保留計數器值+1，表示“我要訪問該對象”。當這段代碼結束對象訪問時，將對象的保留計數器值-1，表示它不再訪問該對象，當 保留計數器值為0時，表示不再有代碼訪問該對象了，因此該對象被銷毀，其占用的內存被系統回收以便重用。
alloc，new，copy 1
retain +1
release -1
3)對象所有權
如果一個對象具有指向其他對象的實力變量，則稱該對象擁有這些對象。
在類A中 B對象擁有其指向的C對象，則B對象擁有C對象。
如果一個函數創建了一個對象，則稱該函數擁有它創建的這個對象。
main()函數創建了對象a 稱main()函數擁有a對象
當多個實體擁有某個特定的對象時，對象的所有權關系就更加復雜了，這也是保留計數器值可能大於1的原因。
例子：
main() {
Engine *engine = [Engine new];
[car setEngine:engine];
}
現在哪個實體擁有engine對象？是main函數還是car類？哪個實體負責確保當engine對象不再被使用時能夠收到release消息？因 為 car類正在使用engine對象，所以不可能是main函數。因為main函數隨後還可能會使用engine對象，所以也不可能是car類。
解決方法是讓car類保留engine對象，將engine對象的保留計數器值增加到2。這是因為car類和main函數這2個實體都正在使用 engine對象。car類應該在setEngine：方法中保留engine對象，而main函數應該釋放engine對象。然後，當car類完成其任 務時再釋放engine對象(在其dealloc方法中)，最後engine對象占用的資源被回收。
如果您使用名字以“alloc”或“new”開頭或名字中包含“copy”的方法（例如alloc，newObject或mutableCopy） 創建了 一個對象，則您會獲得該對象的所有權；或者如果您向一個對象發送了一條retain消息，則您也會獲得該對象的所有權。
4)訪問方法中得保留和釋放
5)自動釋放池NSAutoreleasePool
是一個存放實體的池(集合)。你可以用NSMutableArray來編寫自己的自動釋放池，以容納對象並在dealloc方法中向池中得所有對象發送release消息。
autorelease
當給一個對象發送autorelease消息時，實際上是將該對象添加到NSAutoreleasePool中。當自動釋放池被銷毀時，會向該池中得所有對象發送release消息。
6)自動釋放池的銷毀時間
在我們一直使用的Foudation庫工具中，創建和銷毀自動釋放池的方法非常明確：
NSAutoreleasePool *pool;
pool = [[NSAutoreleasePool alloc] init];
...
[pool release];
創建一個自動釋放池時，該池自動成為活動的池。釋放該池時，其保留計數器值歸0，然後該池被銷毀。在銷毀的過程中，該池釋放其包含的所有對象。當使 用 Application Kit時，cocoa定期自動為你創建和銷毀自動釋放池。通常是在程序處理完當前事件以後執行這些操作。你可以使用任意多得自動 釋放對象，當不再使用它們時，自動釋放池將自動為你清理這些對象。
你可能已經在xcode自動生成代碼中遇見過另一種銷毀自動釋放池中對象的方式：-drain方法。該方法只是清空自動釋放池而不是銷毀它。並且只適用於mac os x10.4以上的版本。
7)自動釋放池的工作過程
我們在任何時候向一個對象發送autorelease消息，該對象都會呗添加到這個自動釋放池中。被加入到自動釋放池的對象的引用計數器值不會變 化。當自 動釋放池被銷毀時(向自動釋放池發送release消息，自動釋放池的引用計數器值變為0，調用自身的dealloc函數)，會調用自身的dealloc 函數，會向池中得對象發送release消息。
別走開，下頁更精彩
37.cocoa內存管理規則
1)當你使用new，alloc或copy方法創建一個對象時，該對象的保留計數器值為1。當不再使用該對象時，你要負責向該對象發送一條release或autorelease消息。這樣，該對象將在其使用壽命結束時被銷毀。
2)當你通過任何其他方法獲得一個對象時，則假設該對象的保留計數器值為1，而且已經被設置為自動釋放，你不需要執行任何操作來確保該對象被清理。如果你打算在一段時間內擁有該對象，則需要保留它並確保在操作完成時釋放它。
3)如果你保留了某個對象，你需要(最終)釋放或自動釋放該對象。必須保持retain方法和release方法的使用次數相同。
38.清理自動釋放池
由於自動釋放池的銷毀時間是完全確立的，所以它在循環執行過程中不會被銷毀。在迭代中或者循環中，需要建立自己的自動釋放池。
39.垃圾回收gc
自動內存管理機制。objective-c的垃圾回收器是一種繼承性的垃圾回收器。與那些已經存在了一段時間的對象相比，新創建的對象更可能被當成 垃圾。 垃圾回收器定期檢查變量和對象以及他們之間的指針，當發現沒有任何變量指向某個對象時，就將該對象視為應該被丟棄的垃圾。如果你再一個實例變量中指向某個 對象，一定要在某個時候使該實例變量賦值為nil，以取消對該對象的引用並使垃圾回收器知道該對象可以被清理了。
與自動釋放池一樣，垃圾回收器也是在時間循環結束時才觸發。
ARC是什麼？
ARC是iOS 5推出的新功能，全稱叫 ARC(Automatic Reference Counting)。簡單地說，就是代碼中自動加入了retain/release，原先需要手動添加的用來處理內存管理的引用計數的代碼可以自動地由編譯器完成了。
該機能在 iOS 5/ Mac OS X 10.7 開始導入，利用 Xcode4.2 可以使用該機能。簡單地理解ARC，就是通過指定的語 法，讓編 譯器(LLVM 3.0)在編譯代碼時，自動生成實例的引用計數管理部分代碼。有一點，ARC並不是GC，它只是一種代碼靜態分析 （Static Analyzer）工具。
40.分配
是一個新對象誕生的過程。是從操作系統獲得一塊內存並將其指定為存放對象的實例變量的位置。
40.初始化
與分配對應的操作是初始化。初始化從操作系統取得一塊內存。准備用於存儲對象。
嵌套調用技術非常重要，因為初始化方法返回的對象可能與分配的對象不同。
1)初始化時做什麼？
給實例變量賦值並創建你得對象完成任務所需要的其他對象。
2)便利初始化函數
許多類包含便利初始化函數。用來完成某些額外的工作的初始化方法，可以減少你自己完成這些工作的麻煩。
例如：NSString類中-(id)initWithFormat:(NSString *)format,...;
3)指定初始化函數
類中的某個初始化方法被指派為指定初始化函數。該類所有初始化方法使用指定初始化函數執行初始化操作。子類使用其超類的指定初始化函數實現超類的初始化。
例如：其他初始化函數通過指定初始化函數實現。
41.初始化函數規則
不需要為你自己的類創建初始化函數方法。如果不需要設置任何狀態，或者只需要alloc方法將內存清零的默認行為，則不需要擔心init。
如果構造了一個初始化函數，則一定要在你自己的指定初始化函數中調用超類的指定初始化函數。一定要將超類的初始化函數的值賦給self對象，並返回你自己的初始化方法的值。因為超類可能決定返回一個完全不同的對象。
如果初始化函數不止一個，則要選擇一個座位指定初始化函數。被選定的方法應該調用超類指定初始化函數。要按照指定初始化函數的形式實現所有其他初始化函數，就像我們在前面的實現一樣。
42.特性@property
objective-c2.0的特性只適用於mac os x 10.5或更高版本。特性主要應用於cocoa的新組件(尤其是華麗奪目的core Animation效果)。
1)簡化接口
@property預編譯指令的作用是自動生命屬性的setter和getter方法。
2)@synthesize也是一種新的編譯器功能，表示“創建該屬性的訪問器”。
3)點表達式
如果點表達式出現在=左邊，該屬性名稱的setter方法(set方法)將被調用。如果點表達式出現在對象變量右邊，則該屬性名稱的getter方法(get方法)將被調用。
4)特性擴展
@property()括號裡面的東西,是對應在set方法中要添加的語句。比如我在括號裡寫retain，就相當於在它的set方法裡添加了一句 [xx retain]。
@property屬性
屬性分為3類：
1.讀寫屬性（Writability）包含：readwrite / readonly
2.setter語義（Setter Semantics）包含：assign / retain / copy
3.原子性（Atomicity）包含：nonatomic
下面具體說明各個屬性的含義
readwrite / readonly：
決定是否生成set訪問器，readwrite是默認屬性，生成getter和setter方法；readonly只生成getter方法，不生成setter方法。
readonly關鍵字代表setter不會被生成， 所以它不可以和 copy/retain/assign組合使用。
assign / retain / copy:
這些屬性用於指定set訪問器的語義，也就是說，這些屬性決定了以何種方式對數據成員賦予新值。
assign:
直接賦值，索引計數不改變，適用於簡單數據類型，例如：NSIngeter、CGFloat、int、char等。
retain：
指針的拷貝，使用的是原來的內存空間。
對象的索引計數加1。
此屬性只能用於Objective-C對象類型，而不能用於Core Foundation對象。(原因很明顯，retain會增加對象的引用計數，而基本數據類型或者Core Foundation對象都沒有引用計數)。
copy：
對象的拷貝，新申請一塊內存空間，並把原始內容復制到那片空間。
新對象的索引計數為1。
此屬性只對那些實行了NSCopying協議的對象類型有效。
很多Objective-C中的object最好使用用retain，一些特別的object（例如：string）使用copy。
nonatomic：
非原子性訪問，不加同步，多線程並發訪問會提高性能。如果不加此屬性，則默認是兩個訪問方法都為原子型事務訪問。默認值是atomic，為原子操作。
（atomic是Objc使用的一種線程保護技術，基本上來講，是防止在寫未完成的時候被另外一個線程讀取，造成數據錯誤。而這種機制是耗費系統資源的， 所以在iPhone這種小型設備上，如果沒有使用多線程間的通訊編程，那麼nonatomic是一個非常好的選擇。）
5)保留周期retain cycle
引用計數器在該周期中歸零。
6)什麼是屬性訪問器
屬性訪問器（Property Accessor），包括 get 訪問器和 set 訪問器分別用於字段的讀寫操作
其設計目的主要是為了實現面向對象（OO）中的封裝思想。根據該思想，字段最好設為private，一個精巧的類最好不要直接把字段設為公有提供給客戶調用端直接訪問
另外要注意屬性本身並不一定和字段相聯系
7)self.a與a的區別
self.a使編譯器知道我們期望使用訪問器訪問a。如果只使用裸名a，編譯器將假設我們直接修改了實例變量。
8)self.a = nil
這行代碼表示使用nil參數調用setName:方法。生成的訪問器方法將自動釋放以前的name對象，並使用nil替代a。該方法完成了釋放 name對 象所占用內存的操作。當然，也可以只釋放name對象以清理其占用的內存。如果你再dealloc方法以外的地方清除特性，那麼使用"將nil賦值給對 象"的方法可以將特性設置為nil，同時可以使我們避免對已釋放內存的懸空引用問題。
9)特性不是萬能的
有些方法不適合特性所能涵蓋的方法的相當狹小的范圍。特性不支持那些需要接受額外參數的方法。
43.類別@category
1)聲明類別
@interface NSString (NumberConvenience)
-(NSNumber *)lengthAsNumber;
@end
該聲明具有2個特點。首先，現有類位於@interface關鍵字之後，其後是位於圓括號中的一個新名稱。該聲明表示，類別的名稱是 NumberConvenience，而且該類別將向NSString類中添加方法。只要保證類別名稱的唯一性，你可以向一個類中添加任意多得類別。
其次，你可以指定希望向其添加類別的類以及類別的名稱，而且你還可以列出添加的方法，最後以@end結束。由於不能添加新實現變量，因此與類聲明不同的是，類別的聲明中沒有實例變量部分。
2)實現類別
3)類別的局限性
第一，無法向類中添加新的實例變量。類別沒有位置容納實例變量。
第二，名稱沖突，即類別中得方法與現有的方法重名。當發生名稱沖突時，類別具有更高的優先級。你得類別方法將完全取代初始方法，從而無法再使用初始方法。有些編程人員在自己的類別方法中增加一個前綴，以確保不發生名稱沖突。
有一些技術可以克服類別無法增加新實例變量的局限。例如，可以使用全局字典存儲對象與你想要關聯的額外變量之間的映射。但此時你可能需要認真考慮一下，類別是否是完成當前任務的最佳選擇。
4)類別的作用
cocoa中得類別主要用於3個目的：第一，將類的實現分散到不同文件或者不同框架中。第二，創建對私有方法的前向引用。第三，向對象添加非正式協議。
44.run循環是一種cocoa構造，它一直處於阻塞狀態(即不執行任何處理)，知道某些事件發生為止。
45.響應選擇器
一個類別如何知道其委托對象是否能夠處理那些發送給它的消息？
類別首先檢查對象，詢問其能否響應該選擇器。如果該對象能夠響應該選擇器，
1)選擇器@selector()
選擇器只是一個方法名稱，但它以objective-c運行時使用的特殊方式編碼，以快速執行查詢。你可以使用@selector()預編譯指令選擇器，其中方法名位於圓括號中。
46.委托 非正式協議
47.正式協議
與非正式協議一樣，正式協議是一個命名的方法列表。但與非正式協議不同的是，正式協議要求顯式的采用協議。采用協議的辦法是在類的@interface聲明中列出協議名稱。采用協議意味著你承諾實現該協議的所有方法。
1)聲明協議
@protocol NSCopying
-(id)copyWithZone:(NSZone *)zone;
@end
2)采用協議
@interface Car: NSObject
{
}
@end
3)協議和數據類型
如果一個用尖括號括起來的協議名稱跟隨在id之後，則編譯器將知道你期望任意類型的對象，只要其遵守該協議。
4)objective-c2.0的新特性@optional @required
@optional可選擇實現的方法
@required必須實現的方法
因此cocoa中得非正式協議正被帶有@optional的正式協議所取代。
48.Application Kit
1)IBOutlet與IBAction
他們實際上只是APPKit提供的#defines。IBOutlet的定義沒有任何作用，因此將不會對它進行編譯。IBAction定義為 void，這 意味著在AppController中聲明的方法的返回類型將使void。IBOutlet和IBAction不執行任何操作，他們並不是用於編譯的，實 際上他們是為Interface Builder以及閱讀代碼的人提供的標記。通過查找IBOutlet和 IBAction，Interface Builder知道AppController對象具有兩個能夠連接的實例變量。
2)IBOutlet是如何工作的
當加載nib文件時(MainMenu.nib會在應用程序啟動時自動加載，可以創建你自己的nib文件並自行加載)，存儲在nib文件中得任何對 象都會 被重新創建。這意味著會再後台執行alloc和init方法。所以，當應用程序啟動時，會分配並初始化一個AppController實例。在執行 init方法期間，所有IBOutlet實例變量都為nil。只有創建了nib文件中得所有對象(這包括窗口和文本域和按鈕),所有連接才算完成。
一旦建立了所有連接(也就是將NSTextField對象的地址添加到AppController的實例變量中)，會向創建的每個對象發送消息 awakeFromNib。一個非常常見的錯誤是試圖在init方法中使用IBOutlet執行一些操作。由於所有實例變量都為nil，發送給他們的所有 消息不執行任何操作，所以在init中得任何嘗試都會發生無提示失敗。(這是Cocoa導致效率低和占用大量調試時間的一個方面)。如果你想知道為什麼這 些操作不起作用，可以使用NSLog輸出實例變量的值，並查看他們是否都為nil。對於創建的對象和發送的awakeFromNib消息，都不存在預定義 順序。
文件加載與保存
49.屬性列表
1)自動釋放對象
NSDate
NSData NSData對象是不可改變的。他們被創建後就不能改變。可以使用他們，但不能改變其中的內容。
2)編碼對象 編碼和解碼
cocoa具備一種機制來將對象自身轉換為某種格式並保存到磁盤中。對象可以將他們的實例變量和其他數據塊編碼為數據塊，然後保存到磁盤中。以後將這些數據塊讀回到內存中，並且還能基於保存的數據創建新對象。這個過程稱為編碼和解碼。或稱為序列化和反序列化。
50.鍵/值編碼 KVC
是一種間接改變對象狀態的方式，其實現方法是使用字符串描述要更改的對象狀態部分。
1)valueForKey與setValue:forKey:
這兩種方法的工作方式相同。他們首先查找名稱的setter(getter)方法，如果不存在setter(getter)方法，他們將在類中查找名為名稱或_名稱的實例變量。然後給它賦值(取值)。無需通過對象指針直接訪問實例變量。
2)路徑
鍵路徑的深度是任意的，具體取決於對象圖。
鍵路徑不僅能引用對象值，還可以引用一些運算符來進行一些運算，例如獲取一組值的平均值或返回這組值中得最小值和最大值。
例如：NSNumber *count;
count = [garage valueForKeyPath:@"cars.@count"];
NSLog(@"We have %@ cars", count);
我們將路徑“cars.@count”拆開，cars用於獲取cars屬性，它是來自garage的NSArray類型的值。接下來的部分是@count ，其中@符號意味著後面將進行一些運算。
3)整體操作
KVC非常棒的一點是，如果向NSArray請求一個鍵值，它實際上會查詢數組中得每個對象來查找這個鍵值，然後將查詢結果打包到另一個數組中並返回給你。這種方法也適用於通過鍵路徑訪問的對象內部的數組。
4)批處理
KVC包含兩個調用，可以使用他們對對象進行批量更改。第一個調用是dictionaryWith-ValuesForKeys：。它接受一個字符串數組。該調用獲取一些鍵，對每個鍵使用valueForKey：，然後為鍵字符串和剛才獲取的值構建一個字典。
---------------------------------------
1、Object-C有多繼承嗎？沒有的話用什麼代替？cocoa 中所有的類都是NSObject 的子類
多繼承在這裡是用protocol 委托代理 來實現的
你不用去考慮繁瑣的多繼承 ,虛基類的概念.
ood的多態特性 在 obj-c 中通過委托來實現.
2、Object-C有私有方法嗎？私有變量呢？
objective-c C 類裡面的方法只有兩種, 靜態方法和實例方法. 這似乎就不是完整的面向對象了,按照OO的原則就是一個對象只暴露有用的東西. 如果沒有了私有方法的話, 對於一些小范圍的代碼重用就不那麼順手了. 在類裡面聲名一個私有方法
@interface Controller : NSObject { NSString *something; }
+ (void)thisIsAStaticMethod;
C (void)thisIsAnInstanceMethod;
@end
@interface Controller (private) -
(void)thisIsAPrivateMethod;
@end
@private可以用來修飾私有變量
在Objective/C中，所有實例變量默認都是私有的，所有實例方法默認都是公有的
3、關鍵字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 類型，以使得其返回值不為“左值”。
4、關鍵字volatile有什麼含義？並給出三個不同例子？
一個定義為volatile的變量是說這變量可能會被意想不到地改變，這樣，編譯器就不會去假設這個變量的值了。精確地說就是，優化器在用到
這個變量時必須每次都小心地重新讀取這個變量的值，而不是使用保存在寄存器裡的備份。下面是volatile變量的幾個例子：
並行設備的硬件寄存器（如：狀態寄存器）
一個中斷服務子程序中會訪問到的非自動變量(Non-automatic variables)
多線程應用中被幾個任務共享的變量
一個參數既可以是const還可以是volatile嗎？解釋為什麼。
一個指針可以是volatile 嗎？解釋為什麼。
下面是答案：
是的。一個例子是只讀的狀態寄存器。它是volatile因為它可能被意想不到地改變。它是const因為程序不應該試圖去修改它。
是的。盡管這並不很常見。一個例子是當一個中服務子程序修該一個指向一個buffer的指針時。
static作用？
函數體內 static 變量的作用范圍為該函數體，不同於 auto 變量，該變量的內存只被分配一次，
因此其值在下次調用時仍維持上次的值；
（2）在模塊內的 static 全局變量可以被模塊內所用函數訪問，但不能被模塊外其它函數訪問；
（3）在模塊內的 static 函數只可被這一模塊內的其它函數調用，這個函數的使用范圍被限制在聲明
它的模塊內；
（4）在類中的 static 成員變量屬於整個類所擁有，對類的所有對象只有一份拷貝；
（5）在類中的 static 成員函數屬於整個類所擁有，這個函數不接收 this 指針，因而只能訪問類的static 成員變量。
6、#import和#include的區別，@class代表什麼？
@class一般用於頭文件中需要聲明該類的某個實例變量的時候用到，在m文件中還是需要使用#import
而#import比起#include的好處就是不會引起重復包含
7、線程和進程的區別？
進程和線程都是由操作系統所體會的程序運行的基本單元，系統利用該基本單元實現系統對應用的並發性。
進程和線程的主要差別在於它們是不同的操作系統資源管理方式。進程有獨立的地址空間，一個進程崩潰後，在保護模式下不會對其它進程產生影響，而線程只是一 個進程中的不同執行路徑。線程有自己的堆棧和局部變量，但線程之間沒有單獨的地址空間，一個線程死掉就等於整個進程死掉，所以多進程的程序要比多線程的程 序健壯，但在進程切換時，耗費資源較大，效率要差一些。但對於一些要求同時進行並且又要共享某些變量的並發操作，只能用線程，不能用進程。
8、堆和棧的區別？
管理方式：對於棧來講，是由編譯器自動管理，無需我們手工控制；對於堆來說，釋放工作由程序員控制，容易產生memory leak。
申請大小：
棧：在Windows下,棧是向低地址擴展的數據結構，是一塊連續的內存的區域。這句話的意思是棧頂的地址和棧的最大容量是系統預先規定好的，在 WINDOWS下，棧的大小是2M（也有的說是1M，總之是一個編譯時就確定的常數），如果申請的空間超過棧的剩余空間時，將提示overflow。因 此，能從棧獲得的空間較小。
堆：堆是向高地址擴展的數據結構，是不連續的內存區域。這是由於系統是用鏈表來存儲的空閒內存地址的，自然是不連續的，而鏈表的遍歷方向是由低地址向高地址。堆的大小受限於計算機系統中有效的虛擬內存。由此可見，堆獲得的空間比較靈活，也比較大。
碎片問題：對於堆來講，頻繁的new/delete勢必會造成內存空間的不連續，從而造成大量的碎片，使程序效率降低。對於棧來講，則不會存在這個問題，因為棧是先進後出的隊列，他們是如此的一一對應，以至於永遠都不可能有一個內存塊從棧中間彈出
分配方式：堆都是動態分配的，沒有靜態分配的堆。棧有2種分配方式：靜態分配和動態分配。靜態分配是編譯器完成的，比如局部變量的分配。動態分配由alloca函數進行分配，但是棧的動態分配和堆是不同的，他的動態分配是由編譯器進行釋放，無需我們手工實現。
分配效率：棧是機器系統提供的數據結構，計算機會在底層對棧提供支持：分配專門的寄存器存放棧的地址，壓棧出棧都有專門的指令執行，這就決定了棧的效率比較高。堆則是C/C++函數庫提供的，它的機制是很復雜的。
9、Object-C的內存管理？
1.當你使用new,alloc和copy方法創建一個對象時,該對象的保留計數器值為1.當你不再使用該對象時,你要負責向該對象發送一條release或autorelease消息.這樣,該對象將在使用壽命結束時被銷毀.
2.當你通過任何其他方法獲得一個對象時,則假設該對象的保留計數器值為1,而且已經被設置為自動釋放,你不需要執行任何操作來確保該對象被清理.如果你打算在一段時間內擁有該對象,則需要保留它並確保在操作完成時釋放它.
3.如果你保留了某個對象,你需要(最終)釋放或自動釋放該對象.必須保持retain方法和release方法的使用次數相等.
10、為什麼很多內置的類，如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永遠留在內存中。
這種情況，必須打斷循環引用，通過其他規則來維護引用關系。比如，我們常見的delegate往往是assign方式的屬性而不是retain方式的屬 性，賦值不會增加引用計數，就是為了防止delegation兩端產生不必要的循環引用。如果一個UITableViewController 對象a通 過retain獲取了UITableView對象b的所有權，這個UITableView對象b的delegate又是a，如果這個delegate是 retain方式的，那基本上就沒有機會釋放這兩個對象了。自己在設計使用delegate模式時，也要注意這點。
11、定義屬性時，什麼情況使用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];
}
12、對象是什麼時候被release的？
引用計數為0時。
autorelease實際上只是把對release的調用延遲了，對於每一個Autorelease，系統只是把該Object放入了當前的 Autorelease pool中，當該pool被釋放時，該pool中的所有Object會被調用Release。對於每一個Runloop，系統會 隱式創建一個Autorelease pool，這樣所有的release pool會構成一個象CallStack一樣的一個棧式結構，在每一個 Runloop結束時，當前棧頂的Autorelease pool會被銷毀，這樣這個pool裡的每個Object（就是autorelease的對 象）會被release。那什麼是一個Runloop呢？一個UI事件，Timer call， delegate call， 都會是一個新的 Runloop
13、iOS有沒有垃圾回收？
Objective-C 2.0也是有垃圾回收機制的，但是只能在Mac OS X Leopard 10.5 以上的版本使用。
14、tableView的重用機制？
查看UITableView頭文件，會找到NSMutableArray* visiableCells，和 NSMutableDictnery* reusableTableCells兩個結構。visiableCells內保存當前顯示的 cells，reusableTableCells保存可重用的cells。
TableView顯示之初，reusableTableCells為空，那麼 tableView dequeueReusableCellWithIdentifier:CellIdentifier返回nil。開始的cell都 是通過 [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier] 來創建，而且cellForRowAtIndexPath只是調用最大顯示cell數的次數。
比如：有100條數據，iPhone一屏最多顯示10個cell。程序最開始顯示TableView的情況是：
1.用 [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier] 創建10次cell，並給cell指定同樣的重用標識(當然，可以為不同顯示類型的cell指定不同的標識)。並且10個cell全部都加入到 visiableCells數組，reusableTableCells為空。
2.向下拖動tableView，當cell1完全移出屏幕，並且cell11(它也是alloc出來的，原因同上)完全顯示出來的時候。 cell11加入到visiableCells，cell1移出visiableCells，cell1加入到reusableTableCells。
3.接著向下拖動tableView，因為reusableTableCells中已經有值，所以，當需要顯示新的 cell，cellForRowAtIndexPath再次被調用的時 候，tableView dequeueReusableCellWithIdentifier:CellIdentifier，返回cell1。 cell1加入到visiableCells，cell1移出reusableTableCells；cell2移出 visiableCells，cell2加入到reusableTableCells。之後再需要顯示的Cell就可以正常重用了。
15、ViewController 的loadView、viewDidLoad、viewDidUnload分別是什麼時候調用的，在自定義ViewCointroller時在這幾個函數中應該做什麼工作？
由init、loadView、viewDidLoad、viewDidUnload、dealloc的關系說起
init方法
在init方法中實例化必要的對象（遵從LazyLoad思想）
init方法中初始化ViewController本身
loadView方法
當view需要被展示而它卻是nil時，viewController會調用該方法。不要直接調用該方法。
如果手工維護views，必須重載重寫該方法
如果使用IB維護views，必須不能重載重寫該方法
loadView和IB構建view
你在控制器中實現了loadView方法，那麼你可能會在應用運行的某個時候被內存管理控制調用。 如果設備內存不足的時候， view 控制器會收到 didReceiveMemoryWarning的消息。 默認的實現是檢查當前控制器的view是否在使用。如果它的view不在當前正在使用的 view hierarchy裡面，且你的控制器實現了loadView方法，那麼這個view將被release, loadView方法將被再次調用 來創建一個新的view。
viewDidLoad方法
viewDidLoad 此方法只有當view從nib文件初始化的時候才被調用。
重載重寫該方法以進一步定制view
在iPhone OS 3.0及之後的版本中，還應該重載重寫viewDidUnload來釋放對view的任何索引
viewDidLoad後調用數據Model
viewDidUnload方法
當系統內存吃緊的時候會調用該方法（注：viewController沒有被dealloc）
內存吃緊時，在iPhone OS 3.0之前didReceiveMemoryWarning是釋放無用內存的唯一方式，但是OS 3.0及以後viewDidUnload方法是更好的方式
在該方法中將所有IBOutlet（無論是property還是實例變量）置為nil（系統release view時已經將其release掉了）
在該方法中釋放其他與view有關的對象、其他在運行時創建（但非系統必須）的對象、在viewDidLoad中被創建的對象、緩存數據 等 release對象後，將對象置為nil（IBOutlet只需要將其置為nil，系統release view時已經將其release掉了）
一般認為viewDidUnload是viewDidLoad的鏡像，因為當view被重新請求時，viewDidLoad還會重新被執行
viewDidUnload中被release的對象必須是很容易被重新創建的對象（比如在viewDidLoad或其他方法中創建的對象），不要release用戶數據或其他很難被重新創建的對象
dealloc方法
viewDidUnload和dealloc方法沒有關聯，dealloc還是繼續做它該做的事情
16、ViewController的didReceiveMemoryWarning是在什麼時候調用的？默認的操作是什麼？
當程序接到內存警告時View Controller將會收到這個消息：didReceiveMemoryWarning
從iOS3.0開始，不需要重載這個函數，把釋放內存的代碼放到viewDidUnload中去。
這個函數的默認實現是:檢查controller是否可以安全地釋放它的view(這裡加粗的view指的是controller的view屬性)，比如view本身沒有superview並且可以被很容易地重建（從nib或者loadView函數）。
如果view可以被釋放，那麼這個函數釋放view並調用viewDidUnload。
你可以重載這個函數來釋放controller中使用的其他內存。但要記得調用這個函數的super實現來允許父類（一般是UIVIewController）釋放view。
如果你的ViewController保存著view的子view的引用，那麼，在早期的iOS版本中，你應該在這個函數中來釋放這些引用。而在iOS3.0或更高版本中，你應該在viewDidUnload中釋放這些引用。
17、列舉Cocoa中常見的集中多線程的實現，並談談多線程安全的幾種解決辦法，一般什麼地方會用到多線程？
NSThread,GCD等。盡量用上層分裝好的方法去實現多線程而不是手動調用NSThread。
18、怎麼理解MVC，在Cocoa中MVC是怎麼實現的？
Model: 代表你的應用程序是什麼（不是怎麼展現）
Controller: 控制你的Model怎麼展現給用戶（UI邏輯）
View: Controller的奴隸。。。
1 Model，Controller，View相互通訊的規則：
Controller可以直接和Model通信
Controller也可以直接和View通信
Model和View永遠不能直接通信
iOS中View和Controller的通信是透明和固定的，主要通過outlet和action實現
View使用Delegate接口和Controller同步信息
View不直接和數據通信，使用dataSource接口從Controller處獲取數據
View的delegate和dataSource一般就是Controller
Controller負責為View翻譯和格式化Model的數據
Model使用Notification & KVO的方式分發數據更新信息，Controller可以有選擇的監聽自己感興趣的信息。
View也可以監聽廣播信息，但一般不是Model發出的信息
一個完整的App就是很多MVC的集合
19、delegate和notification區別，分別在什麼情況下使用？
Delegate:
消息的發送者(sender)告知接收者(receiver)某個事件將要發生，delegate同意然然後發送者響應事件，delegate機制使得接收者可以改變發送者的行為。通常發送者和接收者的關系是直接的一對多的關系。
Notification:
消息的發送者告知接收者事件已經發生或者將要發送，僅此而已，接收者並不能反過來影響發送者的行為。通常發送者和接收者的關系是間接的多對多關系。
1. 效率肯定是delegate比nsnotification高。
2. delegate方法比notification更加直接，最典型的特征是，delegate方法往往需要關注返回值，也就是delegate方法 的結果。比如-windowShouldClose:，需要關心返回的是yes還是no。所以delegate方法往往包含should這個很傳神的詞。 也就是好比你做我的delegate，我會問你我想關閉窗口你願意嗎？你需要給我一個答案，我根據你的答案來決定如何做下一步。相反 的，notification最大的特色就是不關心接受者的態度，我只管把通告放出來，你接受不接受就是你的事情，同時我也不關心結果。所以 notification往往用did這個詞匯，比如NSWindowDidResizeNotification，那麼nswindow對象放出這個 notification後就什麼都不管了也不會等待接受者的反應。
1）兩個模塊之間聯系不是很緊密，就用notification傳值，例如多線程之間傳值用notificaiton。
2）delegate只是一種較為簡單的回調，且主要用在一個模塊中，例如底層功能完成了，需要把一些值傳到上層去，就事先把上層的函數通過 delegate傳到底層，然後在底層call這個delegate，它們都在一個模塊中，完成一個功能，例如 說 NavgationController 從 B 界面到A 點返回按鈕 (調用popViewController方法) 可以用delegate 比較好
20、self.跟self什麼區別？
21、id、nil代表什麼？
id和void *並非完全一樣。在上面的代碼中，id是指向struct objc_object的一個指針，這個意思基本上是說，id是一個指向任何 一個繼承了Object（或者NSObject）類的對象。需要注意的是id是一個指針，所以你在使用id的時候不需要加星號。比如id foo=nil 定義了一個nil指針，這個指針指向NSObject的一個任意子類。而id *foo=nil則定義了一個指針，這個指針指向另一個指針，被指向的這個 指針指向NSObject的一個子類。
nil和C語言的NULL相同，在objc/objc.h中定義。nil表示一個Objctive-C對象，這個對象的指針指向空（沒有東西就是空）。
首字母大寫的Nil和nil有一點不一樣，Nil定義一個指向空的類（是Class，而不是對象）。
SEL是“selector”的一個類型，表示一個方法的名字
Method（我們常說的方法）表示一種類型，這種類型與selector和實現(implementation)相關
IMP定義為 id (*IMP) (id, SEL, …)。這樣說來， IMP是一個指向函數的指針，這個被指向的函數包括id(“self”指針)，調用的SEL（方法名），再加上一些其他參數.說白了IMP就是實現方法。
22、內存管理 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值 = 索引計數(Reference Counting)
NSArray對象會retain(retain值加一)任何數組中的對象。當NSArray被卸載(dealloc)的時候，所有數組中的對象會被 執行一次釋放(retain值減一)。不僅僅是NSArray，任何收集類(Collection Classes)都執行類似操作。例如 NSDictionary，甚至UINavigationController。
Alloc/init建立的對象，索引計數為1。無需將其再次retain。
[NSArray array]和[NSDate date]等“方法”建立一個索引計數為1的對象，但是也是一個自動釋放對象。所以是本地臨時對象，那麼無所謂了。如果是打算在全Class中使用的變量(iVar)，則必須retain它。
缺省的類方法返回值都被執行了“自動釋放”方法。(*如上中的NSArray)
在類中的卸載方法“dealloc”中，release所有未被平衡的NS對象。(*所有未被autorelease，而retain值為1的)
23、類別的作用？
有時我們需要在一個已經定義好的類中增加一些方法，而不想去重寫該類。比如，當工程已經很大，代碼量比較多，或者類中已經包住很多方法，已經有其他代碼調用了該類創建對象並使用該類的方法時，可以使用類別對該類擴充新的方法。
注意：類別只能擴充方法，而不能擴充成員變量。
24、委托（舉例）
委托代理（degegate），顧名思義，把某個對象要做的事情委托給別的對象去做。那麼別的對象就是這個對象的代理，代替它來打理要做的事。反映到程序中，首先要明確一個對象的委托方是哪個對象，委托所做的內容是什麼。
委托機制是一種設計模式，在很多語言中都用到的，這只是個通用的思想，網上會有很多關於這方面的介紹。
那麼在蘋果開發過程中，用到委托的程序實現思想如下，我主要拿如何在視圖之間傳輸信息做個例子。
譬如：在兩個頁面（UIIview視圖對象）實現傳值，用委托（delegate）可以很好做到！
方法：
類A
@interface A：UIView
id transparendValueDelegate;
@property(nomatic, retain) id transparendValueDelegate;
@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之間可以通過委托來傳值！
25、retainCount？
26..屬性readwrite，readonly，assign，retain，copy，nonatomic 各是什麼作用，在那種情況下用
assign：指定setter方法用簡單的賦值，這是默認操作。你可以對標量類型（如int）使用這個屬性。你可以想象一個float，它不是一個對象，所以它不能retain、copy。
retain：指定retain應該在後面的對象上調用，前一個值發送一條release消息。你可以想象一個NSString實例，它是一個對象，而且你可能想要retain它。
copy：指定應該使用對象的副本（深度復制），前一個值發送一條release消息。基本上像retain，但是沒有增加引用計數，是分配一塊新的內存來放置它。
readonly：將只生成getter方法而不生成setter方法（getter方法沒有get前綴）。
readwrite：默認屬性，將生成不帶額外參數的getter和setter方法（setter方法只有一個參數）。
atomic：對於對象的默認屬性，就是setter/getter生成的方法是一個原子操作。如果有多個線程同時調用setter的話，不會出現某一個線程執行setter全部語句之前，另一個線程開始執行setter的情況，相關於方法頭尾加了鎖一樣。
nonatomic：不保證setter/getter的原子性，多線程情況下數據可能會有問題。
27.類變量的@protected ,@private ,@public ,@package聲明各有什麼含義
Objective-C 對存取權限的設定。也是變量的作用域。
protected 該類和所有的子類中的方法可以直接訪問這樣的變量，這是默認的。
private ― 該類中的方法可以訪問這樣的變量，子類不可以。 public ― 除了自己和子類中的方法外，也可以被其他類或者其他模塊中的方法所訪問。開放性最大。 package ― 對於64位圖像，這樣的成員變量可以在實現這個類的圖像中隨意訪問。
28.淺拷貝和深拷貝區別是什麼
簡單的來說就是，在有指針的情況下，淺拷貝只是增加了一個指針指向已經存在的內存，而深拷貝就是增加一個指針並且申請一個新的內存，使這個增加的指針指向這個新的內存，采用深拷貝的情況下，釋放內存的時候就不會出現在淺拷貝時重復釋放同一內存的錯誤
29.Cocoa中與虛基類的概念麼？怎麼簡潔的實現
30.NSString 和 NSMutableString 有什麼區別
NSString相當於一個const char* 不可以改變。
而 NSMutableString相當於 char* 可以改變內部的內容。
31.自動釋放池跟GC有什麼區別？iPhone上有GC麼？［pool release］ 和［pool drain］有什麼區別
”Autorelease Pools”(自動釋放池)在應用中的使用技巧。
1，Autorelease Pools概要
一個”Autorelease Pool”實例中“包含”其它各種調用了”autorelease”方法的對象。當它釋放時，其中所有被管理對象都會收 到”relrease”的消信。注意，同一個對象可以被多次調用”autorelease”方法，並可以放到同一個”Autorelease Pool” 中。引入這個自動釋放池機制，對象的”autorelease”方法代替”relrease”方法可以延長它的生命周期，直接到當 前”Autorelrease Pool”釋放。如果想讓此對象的生命周期超過”Autorelease Pool”，還可以再次”retain”，呵 呵，有意思吧?且讓我慢慢道來。
Cocoa總是認為當前至少有一個”Autorelease Pool”對象是可用的。若此對象並不存在，你調用的”autorelease”的所有對象都不會被自動釋放掉，可想而知，造成內存洩露。Cocoa把這個錯誤信息寫入日志??僅僅是為了以後分析。
你可以用”alloc”與”init”方法創建一個”NSAutoreleasePool”對象，並且可以調用”release”或”drain” （”release”與”drain”的區別是”drain”在有GC的環境中會引起GC回收操作，”release”反之。但在非GC環境中，兩者相 同。官方的說法是為了程序的兼容性，應該考慮用”drain”代替”release”，）方法來回收它（調用它的”autorelease” 或”retain”方法會引起異常）。在一個完整的上下文最後”Autorelease Pool”對象應該被”release”掉（在方法內或一段循環 體內創建的”Autorelease Pool”對象）。
“Autorelease Pools”的所有實例在棧中管理（我們暫時叫他“自動釋放池棧”），並且它們是可以被嵌套的（父生子，子生孫。。。子子孫 孫 ^_^）。例如，當我們創建一個”Autorelease Pool”對象後，它就被自動放到“自動釋放池棧”的棧頂。當本池對象回收時，它就隨之從 這個棧中POP掉。那麼也就是說，當任何一個對象調用”autorelease”方法後，它會被放入當前線程中當前棧頂的自動釋放池中。
接下來我們聊聊”Autorelease Pools”的嵌套問題。在你的應用中，你可以任意多的創建”Autorelease Pool”對象，而這些 對象被當前線程的“自動釋放池棧”所管理。那麼除了一個接一個的順序創建並銷毀它的情況外，還有一種使用方式，就是嵌套式的創建與使用。例如：在你的主函 數創建了一個”autorelease pool”，然後又調用了創建了”autorelease pool”實例的其它方法；或是在外循環中創建 了”Autorelease Pool”的實例，而內循環中也做了相同的事情。有意思吧，呵呵，嵌套的機制使父Pool實例釋放後，它的所有子Pool也 將釋放。但這裡還存在一些副作用，後續文章會詳細討論。
“Application kit”在一個事件循環裡會自動創建一個”autorelease pool”。像鼠標鍵的按下與釋放，所以你編寫的代碼通常不需要考慮太多這方面的事情。當然，有以下三種情況你會創建與銷毀自己的Pool實例：
1，應用不是基於”Application Kit”，像”Command-line tool”，因為它並沒有內置的”autorelease pools”的支持。
2，創建線程，你必需在線程開始時創建一個”Autorelease Pool”實例。反之，會造成內存池露（會在以後的文章詳細說明線程與池的技巧）。
3，一個循環內創建了太多的臨時對象，你應該為他們創建一個”Autorelease Pool”對象，並在下次循還前銷毀它們。
2，自動釋放池中的”Non-AppKit”應用
在”Non-AppKit”應用中使用自動釋放池的機制其實是相當簡單的事情。你僅僅需要在main()起始處創建”Autorelease Pool” 對象，並在結尾處釋放掉它。就像在Xcode的Foundation Tool的創建模版裡寫的一樣。這個確保你在應用生命周期內至少有一 個”Autorelease Pool”是可用的。但是，這也使所有在此期間的所有”autorelease”的對象都必需在應用結束後才被釋放。這也許 會引起在應用的使用中不斷的增長，所以，你仍然考慮在不同的作用域創建新的”Autorelease Pool”。
大多應用中都存在各種級別的循環機制。在這些應用中，你可以在每個循環內的開頭創建一個”Autorelease Pool”對象，並在結尾處釋放掉它。
例如：
void main()
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSArray *args = [[NSProcessInfo processInfo] arguments];
unsigned count, limit = [args count];
for (count = 0; count < limit; count++)
{
NSAutoreleasePool *loopPool = [[NSAutoreleasePool alloc] init];
NSString *fileContents;
NSString *fileName;
fileName = [args objectAtIndex:count];
fileContents = [[[NSString alloc] initWithContentsOfFile:fileName] autorelease];
// this is equivalent to using stringWithContentsOfFile:
[loopPool release];
}
[pool drain];
exit (EXIT_SUCCESS);
}
在命令行中處理所有以參數傳來的文件。一次循環處理一個文件。在循環的開頭創建一個”NSAutoreleasePool”對象，並在循環結束時釋放掉。 因此，任何在其中創建並調用“autorelease”的對象都將添加到這個Pool實例中，當本池被釋放後，這些對象也將被回收。注意，任何在作用域內 創建的”autoreleased”對象（像”fileName”），雖然並沒有顯示的調用”autorelease”方法，但都將被當前池所管理並釋 放。
32.C和obj-c 如何混用
1）obj-c的編譯器處理後綴為m的文件時，可以識別obj-c和c的代碼，處理mm文件可以識別obj-c,c,c++代碼，但cpp文件必須只能用c/c++代碼，而且cpp文件include的頭文件中，也不能出現obj-c的代碼，因為cpp只是cpp
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
33.響應者鏈是什麼
響應者鏈是Application Kit事件處理架構的中心機制。它由一系列鏈接在一起的響應者對象組成，事件或者動作消息可以沿著這些對象進行傳 遞。如圖6-20顯示的那樣，如果一個響應者對象不能處理某個事件或動作－也就是說，它不響應那個消息，或者不認識那個事件，則將該消息重新發送給鏈中的 下一個響應者。消息沿著響應者鏈向上、向更高級別的對象傳遞，直到最終被處理（如果最終還是沒有被處理，就會被拋棄）。
當Application Kit在應用程序中構造對象時，會為每個窗口建立響應者鏈。響應者鏈中的基本對象是NSWindow對象及其視圖層次。在視圖層次中級別較低的視圖將比級別更高的視圖優先獲得處理事件或動作消息的機會。NSWindow中保有一個第一響應者的引用，它通常是當前窗口中處於選擇狀態的視圖，窗口通常把響應消息的機會首先給它。對於事件消息，響應者鏈通常以發生事件的窗口對應的NSWindow對象作為結束，雖然其它對象也可以作為下一個響應者被加入到NSWindow對象的後面。
34..UIscrollVew用到了什麼設計模式？還能再foundation庫中找到類似的嗎？
組合模式composition，所有的container view都用了這個模式
觀察者模式observer，所有的UIResponder都用了這個模式。
模板(Template)模式，所有datasource和delegate接口都是模板模式的典型應用
33. .timer的間隔周期准嗎？為什麼？怎樣實現一個精准的timer?
NSTimer可以精確到50-100毫秒.
NSTimer不是絕對准確的,而且中間耗時或阻塞錯過下一個點,那麼下一個點就pass過去了
此份面試題包含40個題目，是現在網上能搜索到的一個比較熱的一份，但是答案並不是很詳細和完整，基本答案來著cocoaChina，和一些自己的補充。
34.Difference between shallow copy and deep copy?
淺復制和深復制的區別？
答案：淺層復制：只復制指向對象的指針，而不復制引用對象本身。
深層復制：復制引用對象本身。
意思就是說我有個A對象，復制一份後得到A_copy對象後，對於淺復制來說，A和A_copy指向的是同一個內存資源，復制的只不過是是一個指針，對象本身資源
還是只有一份，那如果我們對A_copy執行了修改操作,那麼發現A引用的對象同樣被修改，這其實違背了我們復制拷貝的一個思想。深復制就好理解了,內存中存在了
兩份獨立對象本身。
用網上一哥們通俗的話將就是：
淺復制好比你和你的影子，你完蛋，你的影子也完蛋
深復制好比你和你的克隆人，你完蛋，你的克隆人還活著。
35.What is advantage of categories? What is difference between implementing a category and inheritance?
類別的作用？繼承和類別在實現中有何區別？
答案：category 可以在不獲悉，不改變原來代碼的情況下往裡面添加新的方法，只能添加，不能刪除修改。
並且如果類別和原來類中的方法產生名稱沖突，則類別將覆蓋原來的方法，因為類別具有更高的優先級。
類別主要有3個作用：
(1)將類的實現分散到多個不同文件或多個不同框架中。
(2)創建對私有方法的前向引用。
(3)向對象添加非正式協議。
繼承可以增加，修改或者刪除方法，並且可以增加屬性。
36.Difference between categories and extensions?
類別和類擴展的區別。
答案：category和extensions的不同在於後者可以添加屬性。另外後者添加的方法是必須要實現的。
extensions可以認為是一個私有的Category。
37.Difference between protocol in objective c and interfaces in java?
oc中的協議和java中的接口概念有何不同？
答案：OC中的代理有2層含義，官方定義為 formal和informal protocol。前者和Java接口一樣。
informal protocol中的方法屬於設計模式考慮范疇，不是必須實現的，但是如果有實現，就會改變類的屬性。
其實關於正式協議，類別和非正式協議我很早前學習的時候大致看過，也寫在了學習教程裡
“非正式協議概念其實就是類別的另一種表達方式“這裡有一些你可能希望實現的方法，你可以使用他們更好的完成工作”。
這個意思是，這些是可選的。比如我門要一個更好的方法，我們就會申明一個這樣的類別去實現。然後你在後期可以直接使用這些更好的方法。
這麼看，總覺得類別這玩意兒有點像協議的可選協議。"
現在來看，其實protocal已經開始對兩者都統一和規范起來操作，因為資料中說“非正式協議使用interface修飾“，
現在我們看到協議中兩個修飾詞：“必須實現(@requied)”和“可選實現(@optional)”。
38.What are KVO and KVC?
答案：kvc:鍵 - 值編碼是一種間接訪問對象的屬性使用字符串來標識屬性，而不是通過調用存取方法，直接或通過實例變量訪問的機制。
很多情況下可以簡化程序代碼。apple文檔其實給了一個很好的例子。
kvo:鍵值觀察機制，他提供了觀察某一屬性變化的方法，極大的簡化了代碼。
具體用看到嗯哼用到過的一個地方是對於按鈕點擊變化狀態的的監控。
比如我自定義的一個button
[cpp]
[self addObserver:self forKeyPath:@"highlighted" options:0 context:nil];
#pragma mark KVO
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
([keyPath isEqualToString:@"highlighted"] ) {
[self setNeedsDisplay];
}
}
對於系統是根據keypath去取的到相應的值發生改變，理論上來說是和kvc機制的道理是一樣的。
對於kvc機制如何通過key尋找到value：
“當通過KVC調用對象時，比如：[self valueForKey:@”someKey”]時，程序會自動試圖通過幾種不同的方式解析這個調用。首先 查找對象是否帶有 someKey 這個方法，如果沒找到，會繼續查找對象是否帶有someKey這個實例變量（iVar），如果還沒有找到，程序會繼續 試圖調用 -(id) valueForUndefinedKey:這個方法。如果這個方法還是沒有被實現的話，程序會拋出一個 NSUndefinedKeyException異常錯誤。
(cocoachina.com注：Key-Value Coding查找方法的時候，不僅僅會查找someKey這個方法，還會查找 getsomeKey這個方法，前面加一個get，或者_someKey以及_getsomeKey這幾種形式。同時，查找實例變量的時候也會不僅僅查找 someKey這個變量，也會查找_someKey這個變量是否存在。）
設計valueForUndefinedKey:方法的主要目的是當你使用-(id)valueForKey方法從對象中請求值時，對象能夠在錯誤發生前，有最後的機會響應這個請求。這樣做有很多好處，下面的兩個例子說明了這樣做的好處。“
來至cocoa，這個說法應該挺有道理。
因為我們知道button卻是存在一個highlighted實例變量.因此為何上面我們只是add一個相關的keypath就行了，
可以按照kvc查找的邏輯理解，就說的過去了。
39.What is purpose of delegates?
代理的作用？
答案：代理的目的是改變或傳遞控制鏈。允許一個類在某些特定時刻通知到其他類，而不需要獲取到那些類的指針。可以減少框架復雜度。
另外一點，代理可以理解為java中的回調監聽機制的一種類似。
40.What are mutable and immutable types in Objective C?
oc中可修改和不可以修改類型。
答案：可修改不可修改的集合類。這個我個人簡單理解就是可動態添加修改和不可動態添加修改一樣。
比如NSArray和NSMutableArray。前者在初始化後的內存控件就是固定不可變的，後者可以添加等，可以動態申請新的內存空間。
41.When we call objective c is runtime language what does it mean?
我們說的oc是動態運行時語言是什麼意思？
答案：多態。 主要是將數據類型的確定由編譯時，推遲到了運行時。
這個問題其實淺涉及到兩個概念，運行時和多態。
簡單來說，運行時機制使我們直到運行時才去決定一個對象的類別，以及調用該類別對象指定方法。
多態：不同對象以自己的方式響應相同的消息的能力叫做多態。意思就是假設生物類（life）都用有一個相同的方法-eat;
那人類屬於生物，豬也屬於生物，都繼承了life後，實現各自的eat，但是調用是我們只需調用各自的eat方法。
也就是不同的對象以自己的方式響應了相同的消息（響應了eat這個選擇器）。
因此也可以說，運行時機制是多態的基礎？~~~
42.what is difference between NSNotification and protocol?
通知和協議的不同之處？
答案：協議有控制鏈(has-a)的關系，通知沒有。
首先我一開始也不太明白，什麼叫控制鏈（專業術語了~）。但是簡單分析下通知和代理的行為模式，我們大致可以有自己的理解
簡單來說，通知的話，它可以一對多，一條消息可以發送給多個消息接受者。
代理按我們的理解，到不是直接說不能一對多，比如我們知道的明星經濟代理人，很多時候一個經濟人負責好幾個明星的事務。
只是對於不同明星間，代理的事物對象都是不一樣的，一一對應，不可能說明天要處理A明星要一個發布會，代理人發出處理發布會的消息後，別稱B的
發布會了。但是通知就不一樣，他只關心發出通知，而不關心多少接收到感興趣要處理。
因此控制鏈（has-a從英語單詞大致可以看出，單一擁有和可控制的對應關系。
43.What is push notification?
什麼是推送消息？
答案：太簡單，不作答~~~~~~~~~~
這是cocoa上的答案。
其實到不是說太簡單，只是太泛泛的一個概念的東西。就好比說，什麼是人。
推送通知更是一種技術。
簡單點就是客戶端獲取資源的一種手段。
普通情況下，都是客戶端主動的pull。
推送則是服務器端主動push。
44.Polymorphism？
關於多態性
答案：多態，子類指針可以賦值給父類。
這個題目其實可以出到一切面向對象語言中，
因此關於多態，繼承和封裝基本最好都有個自我意識的理解，也並非一定要把書上資料上寫的能背出來。
最重要的是轉化成自我理解。
45.Singleton?
對於單例的理解
答案：11，12題目其實出的有點泛泛的感覺了，可能說是編程語言需要或是必備的基礎。
基本能用熟悉的語言寫出一個單例，以及可以運用到的場景或是你編程中碰到過運用的此種模式的框架類等。
進一步點，考慮下如何在多線程訪問單例時的安全性。
46.What is responder chain?
說說響應鏈
答案： 事件響應鏈。包括點擊事件，畫面刷新事件等。在視圖棧內從上至下，或者從下之上傳播。
可以說點事件的分發，傳遞以及處理。具體可以去看下touch事件這塊。因為問的太抽象化了
嚴重懷疑題目出到越後面就越笼統。
47.Difference between frame and bounds?
frame和bounds有什麼不同？
答案:frame指的是：該view在父view坐標系統中的位置和大小。（參照點是父親的坐標系統）
bounds指的是：該view在本身坐標系統中 的位置和大小。（參照點是本身坐標系統）
48.Difference between method and selector?
方法和選擇器有何不同？
答案：selector是一個方法的名字，method是一個組合體，包含了名字和實現.
詳情可以看apple文檔。
49.Is there any garbage collection mechanism in Objective C.?
OC的垃圾回收機制？
答案： OC2.0有Garbage collection，但是iOS平台不提供。
一般我們了解的objective-c對於內存管理都是手動操作的，但是也有自動釋放池。
但是差了大部分資料，貌似不要和arc機制搞混就好了。
求更多~~
50.NSOperation queue?
答案：存放NSOperation的集合類。
操作和操作隊列，基本可以看成java中的線程和線程池的概念。用於處理ios多線程開發的問題。
網上部分資料提到一點是，雖然是queue，但是卻並不是帶有隊列的概念，放入的操作並非是按照嚴格的先進現出。
這邊又有個疑點是，對於隊列來說，先進先出的概念是Afunc添加進隊列，Bfunc緊跟著也進入隊列，Afunc先執行這個是必然的，
但是Bfunc是等Afunc完全操作完以後，B才開始啟動並且執行，因此隊列的概念離亂上有點違背了多線程處理這個概念。
但是轉念一想其實可以參考銀行的取票和叫號系統。
因此對於A比B先排隊取票但是B率先執行完操作，我們亦然可以感性認為這還是一個隊列。
但是後來看到一票關於這操作隊列話題的文章，其中有一句提到
“因為兩個操作提交的時間間隔很近，線程池中的線程，誰先啟動是不定的。”
瞬間覺得這個queue名字有點忽悠人了，還不如pool~
綜合一點，我們知道他可以比較大的用處在於可以幫組多線程編程就好了。
51.What is lazy loading?
答案：懶漢模式，只在用到的時候才去初始化。
也可以理解成延時加載。
我覺得最好也最簡單的一個列子就是tableView中圖片的加載顯示了。
一個延時載，避免內存過高，一個異步加載，避免線程堵塞。
52.Can we use two tableview controllers on one viewcontroller?
是否在一個視圖控制器中嵌入兩個tableview控制器？
答案：一個視圖控制只提供了一個View視圖，理論上一個tableViewController也不能放吧，
只能說可以嵌入一個tableview視圖。當然，題目本身也有歧義，如果不是我們定性思維認為的UIViewController，
而是宏觀的表示視圖控制者，那我們倒是可以把其看成一個視圖控制者，它可以控制多個視圖控制器，比如TabbarController
那樣的感覺。
53.Can we use one tableview with two different datasources? How you will achieve this?
一個tableView是否可以關聯兩個不同的數據源？你會怎麼處理？
答案：首先我們從代碼來看，數據源如何關聯上的，其實是在數據源關聯的代理方法裡實現的。
因此我們並不關心如何去關聯他，他怎麼關聯上，方法只是讓我返回根據自己的需要去設置如相關的數據源。
因此，我覺得可以設置多個數據源啊，但是有個問題是，你這是想干嘛呢？想讓列表如何顯示，不同的數據源分區塊顯示？
