3、請說明一下objective-c中#import 、#include 及@class的區別？#import<>跟#import”"有什么區別?

.#import 是oc導入頭文件的關鍵字，#include是c/c++導入頭文件的關鍵字，#import會自動導入一次，不會重復導入，不會引起交叉編譯，@class告訴編譯器某個類的聲明，當執行是才去查看類的執行文件，當兩個類文件有循環依賴關系(A引用B,B引用A)時，需要用@class，
在interface中引用一個類，就用@class，它會把這個類作為一個類型來使用，而在實現這個interface的文件中，如果需要引用這個類的實體變量或者方法之類的，還是需要import這個在@class中聲明的類。
＃import<>引用系統文件，它用于對系統自帶的頭文件的引用，編譯器會在系統文件目錄下去查找該文件.
.#import"":用戶自定義的文件用雙引號引用，編譯器首先會在用戶目錄下查找，然后到安裝目錄中查

.#include <x.h>:它用于對系統自帶的頭文件的引用，編譯器會在系統文件目錄下去查找該文件.
.#include "x.h":用戶自定義的文件用雙引號引用，編譯器首先會在用戶目錄下查找，然后到安裝目錄中查找，最后在系統文件中查找。
在使用#include的時候要注意處理重復引用（這也是objc中#include與#import的區別）
例如：ClassA 與 ClassB同時引用了ClassC，不做重復引用處理的時候在ClassD中同時引用ClassA，ClassB編譯會提示對ClassC重復引用的錯誤.
我們可以:#ifndef _CLASSC_H
#define _CLASSC_H
#include "ClassC"
#endif
這樣處理在編譯時就不會有重復引用的錯誤出現（在objc中#import解決了這個問題，這是它們的區別）

.#import--避免重復引用
#import 大部分功能和#include是一樣的，但是他處理了重復引用的問題，我們在引用文件的時候不用再去自己進行重復引用處理.
@class--避免循環引用
主要是用于聲明一個類，告訴編譯器它后面的名字是一個類的名字，而這個類的定義實現是暫時不用知道的，后面會告訴你.也是因為在@class僅僅只是聲明一個類，所以在后面的實現文件里面是需要去#import這個類，這時候才包含了這個被引用的類的所有信息。

.#include與#import在引用一個類的時候會包含這個類的所有信息包括變量方法等，但是這樣做會對編譯效率造成影響.比如有100個類都#import了ClassA，那么在編譯的時候這100個類都會去對ClassA處理.又比如A被B引用，B被C引用，C被D引用.....此時如果A被修改，那么后面的B，C，D.....都需要重新進行編譯.還有一個用法會引起編譯錯誤的就是在ClassA中#import ClassB 在ClassB中#import ClassA那么在編譯的時候也會出現未知錯誤。所以一般來說，在interface中引用一個類，就用@class，它會把這個類作為一個類型來使用，而在實現這個interface的文件中，如果需要引用這個類的實體變量或者方法之類的，還是需要import這個在@class中聲明的類。@class只是簡單的一個聲明告編譯器有這個類不讓其報錯，那么.m中要用到引入的類的方法和屬性時，不還是要#import頭文件一次，是的這個是對的，但編譯器編譯的時候只編譯頭文件的，所以你的.m中用#import與編譯時間沒太大關系

什么時候該用#import進行聲明
(1)一般如果有繼承關系的用#import，如Ｂ是Ａ的子類那么在Ｂ中聲明Ａ時用#import
(2) 另外就是如果有循環依賴關系，如：A->B,B->A這樣相互依賴時，如果在兩個文件的頭文件中用#import分別聲明對方，那么就會出現頭文件循環利用的錯誤，這時在頭文件中用@class聲明就不會出錯
(3)還有就是自定義代理的時候，如果在頭文件中想聲明代理的話如@interface SecondViewController:UIViewController時應用#import不然的話會出錯誤，注意ＸＸＸＸDelegate是自定義的

1. 一般來說，導入objective c的頭文件時用#import，包含c/c++頭文件時用#include。
2. .#import 確定一個文件只能被導入一次，這使你在遞歸包含中不會出現問題。<標記>
   所以，#import比起#include的好處就是不會引起交叉編譯。

.#import && #class:

1. import會包含這個類的所有信息，包括實體變量和方法（.h文件中），而@class只是告訴編譯器，其后面聲明的名稱是類的名稱，至于這些類是如何定義的，后面會再告訴你。
2. 在頭文件中， 一般只需要知道被引用的類的名稱就可以了。 不需要知道其內部的實體變量和方法，所以在頭文件中一般使用@class來聲明這個名稱是類的名稱。 而在實現類里面，因為會用到這個引用類的內部的實體變量和方法，所以需要使用#import來包含這個被引用類的頭文件。
   備注：#import 就是把被引用類的頭文件走一遍，即把.h文件里的變量和方法包含進來一次，且僅一次，而@class不用，所以后者編譯效率更高。
3. 在編譯效率方面考慮，如果你有100個頭文件都#import了同一個頭文件，或者這些文件是依次引用的，如A–>B, B–>C, C–>D這樣的引用關系。當最開始的那個頭文件有變化的話，后面所有引用它的類都需要重新編譯，如果你的類有很多的話，這將耗費大量的時間。而是用@class則不會。
4. 如果有循環依賴關系，如:A–>B, B–>A這樣的相互依賴關系，如果使用#import來相互包含，那么就會出現編譯錯誤，如果使用@class在兩個類的頭文件中相互聲明，則不會有編譯錯誤出現。
   備注：實踐證明，A,B相互#import不會出現編譯錯誤。因為<標記>處已經說明#import時文件只被導入一次，所以此條不成立。
   總結：
   1.如果不是c/c++，盡量用#import。
   2.能在實現文件中#import，就不在頭文件中#import。
   3.能在頭文件中@class+實現文件中#import，就不在頭文件中#import。

（1）#import指令是Object-C針對#include的改進版本，#import確保引用的文件只會被引用一次，這樣就不會陷入遞歸包含的問題中。
（2）#import與@class二者的區別在于：
　　#import會鏈入該頭文件的全部信息，包括實體變量和方法等；而@class只是告訴編譯器，其后面聲明的名稱是類的名稱，至于這些類是如何定義的，暫時不用考慮。在頭文件中， 一般只需要知道被引用的類的名稱就可以了。

1、Object_C的類可以多重繼承么？可以實現多個接口么？Category是什么？重寫一個雷的方式用繼承好還是用分類好？為什么？

Object-c的類不可以多重繼承；可以實現多個接口，通過實現多個接口可以完成C++的多重繼承；
Category是類別，一般情況用分類好，用Category去重寫類的方法，僅對本Category有效，不會影響到其他類與原有類的關系。

3、屬性readwrite，readonly，assign，retain，copy，nonatomic各是什么作用，在哪種情況下使用？

readwrite 是可讀可寫特性；需要生成getter方法和setter方法時（補充：默認屬性，將生成不帶額外參數的getter和setter方法（setter方法只有一個參數））
readonly 是只讀特性 只會生成getter方法 不會生成setter方法 ;不希望屬性在類外改變
assign 是賦值特性，setter方法將傳入參數賦值給實例變量；僅設置變量時；
retain 表示持有特性，setter方法將傳入參數先保留，再賦值，傳入參數的retaincount會+1;
copy 表示拷貝特性，setter方法將傳入對象復制一份；需要完全一份新的變量時。
nonatomic 非原子操作，決定編譯器生成的setter getter是否是原子操作，
atomic表示多線程安全，一般使用nonatomic

最全的iOS面試題及答案

1. Object-c的類可以多重繼承么?可以實現多個接口么?Category是什么?重寫一個類的方式用繼承好還是分類好?為什么?

答： Object-c的類不可以多重繼承;可以實現多個接口，通過實現多個接口可以完成C++的多重繼承;Category是類別，一般情況用分類好，用Category去重寫類的方法，僅對本Category有效，不會影響到其他類與原有類的關系。

2.#import 跟#include 又什么區別，@class呢, #import<> 跟 #import””又什么區別?

答：#import是Objective-C導入頭文件的關鍵字，#include是C/C++導入頭文件的關鍵字,使用#import頭文件會自動只導入一次，不會重復導入，相當于#include和#pragma once;
@class告訴編譯器某個類的聲明，當執行時，才去查看類的實現文件，可以解決頭文件的相互包含;
.#import<>用來包含系統的頭文件；
.#import””用來包含用戶頭文件。

3. 屬性readwrite，readonly，assign，retain，copy，nonatomic 各是什么作用，在那種情況下用?

1. readwrite 是可讀可寫特性;需要生成getter方法和setter方法時。
2. readonly 是只讀特性 只會生成getter方法 不會生成setter方法 ;不希望屬性在類外改變。
3. assign 是賦值特性，setter方法將傳入參數賦值給實例變量;僅設置變量時;
4. retain 表示持有特性，setter方法將傳入參數先保留，再賦值，傳入參數的retaincount會+1;
5. copy 表示賦值特性，setter方法將傳入對象復制一份;需要完全一份新的變量時。
6. nonatomic 非原子操作，決定編譯器生成的setter getter是否是原子操作，atomic表示多線程安全，一般使用nonatomic

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

- (void) setName:(NSString*) str{
    　　[str retain];
    　　[name release];
    　　name = str;
　　}
　　- (void)setName:(NSString *)str
　　{
    　　id t = [str copy];
    　　[name release];
    　　name = t;
　　}

5.對于語句NSString *obj = [[NSData alloc] init]; obj在編譯時和運行時分別時什么類型的對象?

編譯時是NSString的類型;
運行時是NSData類型的對象。

6.常見的object-c的數據類型有那些，和C的基本數據類型有什么區別? 如：NSInteger和int

答：object-c的數據類型有NSString，NSNumber，NSArray，NSMutableArray，NSData等等，這些都是class，創建后便是對象，而C語言的基本數據類型int，只是一定字節的內存空間，用于存放數值;NSInteger是基本數據類型，并不是NSNumber的子類，當然也不是NSObject的子類。NSInteger是基本數據類型Int或者Long的別名(NSInteger的定義typedef long NSInteger)，它的區別在于，NSInteger會根據系統是32位還是64位來決定本身是int還是Long。

7.id 聲明的對象有什么特性?

Id 聲明的對象具有運行時的特性，即可以指向任意類型的objcetive-c的對象;

8.Objective-C如何對內存管理的,說說你的看法和解決方法?

Objective-C的內存管理主要有三種方式：ARC(自動內存計數)、手動內存計數、內存池。

1. (Garbage Collection)自動內存計數：這種方式和java類似，在你的程序的執行過程中。始終有一個高人在背后準確地幫你收拾垃圾，你不用考慮它什么時候開始工作，怎樣工作。你只需要明白，我申請了一段內存空間，當我不再使用從而這段內存成為垃圾的時候，我就徹底的把它忘記掉，反正那個高人會幫我收拾垃圾。遺憾的是，那個高人需要消耗一定的資源，在攜帶設備里面，資源是緊俏商品所以iPhone不支持這個功能。所以“Garbage Collection”不是本入門指南的范圍，對“Garbage Collection”內部機制感興趣的同學可以參考一些其他的資料，不過說老實話“Garbage Collection”不大適合適初學者研究。
   解決: 通過alloc – initial方式創建的, 創建后引用計數+1, 此后每retain一次引用計數+1, 那么在程序中做相應次數的release就好了.
2. (Reference Counted)手動內存計數：就是說，從一段內存被申請之后，就存在一個變量用于保存這段內存被使用的次數，我們暫時把它稱為計數器，當計數器變為0的時候，那么就是釋放這段內存的時候。比如說，當在程序A里面一段內存被成功申請完成之后，那么這個計數器就從0變成1(我們把這個過程叫做alloc)，然后程序B也需要使用這個內存，那么計數器就從1變成了2(我們把這個過程叫做retain)。緊接著程序A不再需要這段內存了，那么程序A就把這個計數器減1(我們把這個過程叫做release);程序B也不再需要這段內存的時候，那么也把計數器減1(這個過程還是release)。當系統(也就是Foundation)發現這個計數器變成了0，那么就會調用內存回收程序把這段內存回收(我們把這個過程叫做dealloc)。順便提一句，如果沒有Foundation，那么維護計數器，釋放內存等等工作需要你手工來完成。
   解決:一般是由類的靜態方法創建的, 函數名中不會出現alloc或init字樣, 如[NSString string]和[NSArray arrayWithObject:], 創建后引用計數+0, 在函數出棧后釋放, 即相當于一個棧上的局部變量. 當然也可以通過retain延長對象的生存期.
3. (NSAutoRealeasePool)內存池：可以通過創建和釋放內存池控制內存申請和回收的時機.
   解決:是由autorelease加入系統內存池, 內存池是可以嵌套的, 每個內存池都需要有一個創建釋放對, 就像main函數中寫的一樣. 使用也很簡單, 比如[[[NSString alloc]initialWithFormat:@”Hey you!”] autorelease], 即將一個NSString對象加入到最內層的系統內存池, 當我們釋放這個內存池時, 其中的對象都會被釋放.

9.原子(atomic)跟非原子(non-atomic)屬性有什么區別?

1. atomic提供多線程安全。是防止在寫未完成的時候被另外一個線程讀取，造成數據錯誤；
2. non-atomic:在自己管理內存的環境中，解析的訪問器保留并自動釋放返回的值，如果指定了 nonatomic ，那么訪問器只是簡單地返回這個值。

10. 看下面的程序,第一個NSLog會輸出什么?這時str的retainCount是多少?第二個和第三個呢? 為什么?

=======================================================
NSMutableArray* ary = [[NSMutableArray array] retain];
NSString *str = [NSString stringWithFormat:@"test"];
[str retain];
[ary addObject:str];
NSLog(@"%@%lu",str,(unsigned long)[str retainCount]);
[str retain];
[str release];
[str release];
NSLog(@"%@%lu",str,(unsigned long)[str retainCount]);
[ary removeAllObjects];
NSLog(@"%@%lu",str,(unsigned long)[str retainCount]);
　　=======================================================
　　str的retainCount創建+1，retain+1，加入數組自動+1 3
　　retain+1，release-1，release-1 2
　　數組刪除所有對象，所有數組內的對象自動-1 1

11. 內存管理的幾條原則時什么?按照默認法則.那些關鍵字生成的對象需要手動釋放?在和property結合的時候怎樣有效的避免內存泄露?

誰申請，誰釋放
遵循Cocoa Touch的使用原則;
內存管理主要要避免“過早釋放”和“內存泄漏”，對于“過早釋放”需要注意@property設置特性時，一定要用對特性關鍵字，對于“內存泄漏”，一定要申請了要負責釋放，要細心。
關鍵字alloc 或new 生成的對象需要手動釋放;
設置正確的property屬性，對于retain需要在合適的地方釋放，

12.如何對iOS設備進行性能測試?

Profile-> Instruments ->Time Profiler

13. Object C中創建線程的方法是什么?如果在主線程中執行代碼，方法是什么?如果想延時執行代碼、方法又是什么?

線程創建有三種方法：使用NSThread創建、使用GCD的dispatch、使用子類化的NSOperation,然后將其加入NSOperationQueue;在主線程執行代碼，方法是performSelectorOnMainThread，如果想延時執行代碼可以用performSelector:onThread:withObject:waitUntilDone:

14.描述一下iOS SDK中如何實現MVC的開發模式

MVC是模型、視圖、控制器開發模式，對于iOS SDK，所有的View都是視圖層的，它應該獨立于模型層，由視圖控制層來控制。所有的用戶數據都是模型層，它應該獨立于視圖。所有的ViewController都是控制層，由它負責控制視圖，訪問模型數據。

15 淺復制和深復制的區別?

答案：淺層復制：只復制指向對象的指針，而不復制引用對象本身。
深層復制：復制引用對象本身。
意思就是說我有個A對象，復制一份后得到A_copy對象后，對于淺復制來說，A和A_copy指向的是同一個內存資源，復制的只不過是是一個指針，對象本身資源還是只有一份，那如果我們對A_copy執行了修改操作,那么發現A引用的對象同樣被修改，這其實違背了我們復制拷貝的一個思想。深復制就好理解了,內存中存在了兩份獨立對象本身。
用網上一哥們通俗的話將就是：
淺復制好比你和你的影子，你完蛋，你的影子也完蛋
深復制好比你和你的克隆人，你完蛋，你的克隆人還活著。

16. 類別的作用?繼承和類別在實現中有何區別?

答案：category 可以在不獲悉，不改變原來代碼的情況下往里面添加新的方法，只能添加，不能刪除修改。并且如果類別和原來類中的方法產生名稱沖突，則類別將覆蓋原來的方法，因為類別具有更高的優先級。
　　類別主要有3個作用：
　　(1)將類的實現分散到多個不同文件或多個不同框架中。
　　(2)創建對私有方法的前向引用。
　　(3)向對象添加非正式協議。
　　繼承可以增加，修改或者刪除方法，并且可以增加屬性。

17. 類別和類擴展的區別。

答案：category和extensions的不同在于extensions可以添加屬性。另外extensions添加的方法是必須要實現的。extensions可以認為是一個私有的Category。

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

答案：OC中的代理有2層含義，官方定義為 formal和informal protocol。前者和Java接口一樣。
　　informal protocol中的方法屬于設計模式考慮范疇，不是必須實現的，但是如果有實現，就會改變類的屬性。
　　其實關于正式協議，類別和非正式協議我很早前學習的時候大致看過，也寫在了學習教程里
　　“非正式協議概念其實就是類別的另一種表達方式“這里有一些你可能希望實現的方法，你可以使用他們更好的完成工作”。
　　這個意思是，這些是可選的。比如我門要一個更好的方法，我們就會申明一個這樣的類別去實現。然后你在后期可以直接使用這些更好的方法。
　　這么看，總覺得類別這玩意兒有點像協議的可選協議。”
　　現在來看，其實protocal已經開始對兩者都統一和規范起來操作，因為資料中說“非正式協議使用interface修飾“，
　　現在我們看到協議中兩個修飾詞：“必須實現(@requied)”和“可選實現(@optional)”。

19. 什么是KVO和KVC?

答案：kvc:鍵 – 值編碼，是一種間接訪問對象的屬性使用字符串來標識屬性，而不是通過調用存取方法，直接或通過實例變量訪問的機制。很多情況下可以簡化程序代碼。apple文檔其實給了一個很好的例子。
kvo:鍵值觀察機制，他提供了觀察某一屬性變化的方法，極大的簡化了代碼。
具體用看到嗯哼用到過的一個地方是對于按鈕點擊變化狀態的的監控。
比如我自定義的一個button
[self addObserver:self forKeyPath:@"highlighted" options:0 context:nil];
#pragma mark KVO
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
    if ([keyPath isEqualToString:@"highlighted"] ) {
        [self setNeedsDisplay];
    }
}
對于系統是根據keypath去取得到相應的值發生改變，理論上來說是和kvc機制的道理是一樣的。
對于kvc機制如何通過key尋找到value：
“當通過KVC調用對象時，比如：[self valueForKey:@”someKey”]時，程序會自動試圖通過幾種不同的方式解析這個調用。首先查找對象是否帶有 someKey 這個方法，如果沒找到，會繼續查找對象是否帶有someKey這個實例變量(iVar)，如果還沒有找到，程序會繼續試圖調用 -(id) valueForUndefinedKey:這個方法。如果這個方法還是沒有被實現的話，程序會拋出一個NSUndefinedKeyException異常錯誤。
(cocoachina.com注：Key-Value Coding查找方法的時候，不僅僅會查找someKey這個方法，還會查找getsomeKey這個方法，前面加一個get，或者_someKey以及_getsomeKey這幾種形式。同時，查找實例變量的時候也會不僅僅查找someKey這個變量，也會查找_someKey這個變量是否存在。)
設計valueForUndefinedKey:方法的主要目的是當你使用-(id)valueForKey方法從對象中請求值時，對象能夠在錯誤發生前，有最后的機會響應這個請求。這樣做有很多好處，下面的兩個例子說明了這樣做的好處。“來至cocoa，這個說法應該挺有道理。
因為我們知道button卻是存在一個highlighted實例變量.因此為何上面我們只是add一個相關的keypath就行了，可以按照kvc查找的邏輯理解，就說的過去了。

20. 代理的作用?

答案：代理的目的是改變或傳遞控制鏈。允許一個類在某些特定時刻通知到其他類，而不需要獲取到那些類的指針。可以減少框架復雜度。
另外一點，代理可以理解為java中的回調監聽機制的一種類似。

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

答案：可修改不可修改的集合類。這個我個人簡單理解就是可動態添加修改和不可動態添加修改一樣。
　　比如NSArray和NSMutableArray。前者在初始化后的內存控件就是固定不可變的，后者可以添加等，可以動態申請新的內存空間。

22. 我們說的oc是動態運行時語言是什么意思?

答案：多態。 主要是將數據類型的確定由編譯時，推遲到了運行時。
　　這個問題其實涉及到兩個概念，運行時和多態。
　　簡單來說，運行時機制使我們直到運行時才去確定一個對象的類別，以及調用該類別對象指定方法。
　　多態：不同對象以自己的方式響應相同的消息的能力叫做多態。意思就是假設生物類(life)都用有一個相同的方法-eat;
　　那人類屬于生物，豬也屬于生物，都繼承了life后，實現各自的eat，但是調用是我們只需調用各自的eat方法。
　　也就是不同的對象以自己的方式響應了相同的消息(響應了eat這個選擇器)。
　　因此也可以說，運行時機制是多態的基礎?~~~

23. 通知和協議的不同之處?

答案：協議有控制鏈(has-a)的關系，通知沒有。
　　首先我一開始也不太明白，什么叫控制鏈(專業術語了~)。但是簡單分析下通知和代理的行為模式，我們大致可以有自己的理解。
　　簡單來說，通知的話，它可以一對多，一條消息可以發送給多個消息接受者。
　　代理按我們的理解，到不是直接說不能一對多，比如我們知道的明星經濟代理人，很多時候一個經濟人負責好幾個明星的事務。
　　只是對于不同明星間，代理的事物對象都是不一樣的，一一對應，不可能說明天要處理A明星要一個發布會，代理人發出處理發布會的消息后，別稱B的
　　發布會了。但是通知就不一樣，他只關心發出通知，而不關心多少接收到感興趣要處理。
　　因此控制鏈(has-a從英語單詞大致可以看出，單一擁有和可控制的對應關系。

3.代理和通知的區別

答：代理通常用于一對一的關系，通知可以是一對一或一對多或一對無的關系。代理的receive可以把結果返回給sender，通知的sender只負責把消息發送出去不需要返回結果。

24. 是推送消息?

答案：太簡單，不作答~~~~~~~~~~
　　這是cocoa上的答案。
　　其實到不是說太簡單，只是太泛泛的一個概念的東西。就好比說，什么是人。
　　推送通知更是一種技術。
　　簡單點就是客戶端獲取資源的一種手段。
　　普通情況下，都是客戶端主動的pull。
　　推送則是服務器端主動push。 測試push的實現可以查看該博文。

25. 關于多態性

答案：多態，子類指針可以賦值給父類。
這個題目其實可以出到一切面向對象語言中，因此關于多態，繼承和封裝基本最好都有個自我意識的理解，也并非一定要把書上資料上寫的能背出來。最重要的是轉化成自我理解。

26. 對于單例的理解

答案：11，12題目其實出的有點泛泛的感覺了，可能說是編程語言需要或是必備的基礎。
　　基本能用熟悉的語言寫出一個單例，以及可以運用到的場景或是你編程中碰到過運用的此種模式的框架類等。
　　進一步點，考慮下如何在多線程訪問單例時的安全性。

27. 說說響應鏈

答案： 事件響應鏈。包括點擊事件，畫面刷新事件等。在視圖棧內從上至下，或者從下之上傳播。
　　可以說點事件的分發，傳遞以及處理。具體可以去看下touch事件這塊。因為問的太抽象化了
　　嚴重懷疑題目出到越后面就越籠統。
　　可以從責任鏈模式，來講通過事件響應鏈處理，其擁有的擴展性

28. frame和bounds有什么不同?

答案:frame指的是：該view在父view坐標系統中的位置和大小。(參照點是父親的坐標系統)
　　bounds指的是：該view在本身坐標系統中 的位置和大小。(參照點是本身坐標系統)

29. 方法和選擇器有何不同?

答案：selector是一個方法的名字，method是一個組合體，包含了名字和實現.

2 淺談ios開發中幾種基本的設計模式

答：
1）模型視圖控制器(MVC)。
控制器負責行為，模型提供數據源，視圖顯示UI。模型和視圖之間盡量不要直接打交道，他們之間的交互應該通過控制器來進行，控制器充當著橋梁的作用。這樣設計的目的是使不同功能的類之間盡量解耦，以利于程序的擴展。

2）代理模式
委托代理（degegate），顧名思義，把某個對象要做的事情委托給別的對象去做。那么別的對象就是這個對象的代理，代替它來打理要做的事。反映到程序中，首先要明確一個對象的委托方是哪個對象，委托所做的內容是什么。這里所做的內容是靠協議中的方法來實現，方法分兩種：必需實現(@required)的方法和根據情況選擇實現(@optional)的方法。
舉個例子：你是房屋租賃中介，某個房東和你簽訂協議，請你替他把房子出租出去。這時，你就是房東的代理，你必須實現的方法是把屋子出租出去，選擇實現的方法是裝修、添置家具、打隔斷等（依據協議而定）。

3）通知模式
通知模式是觀察者模式的一種。a對象在通知中心注冊了觀察者之后，b對象發出通知廣播，a對象收到通知后就知道去做具體的事。觀察者可以是一個或多個，也可以沒有。舉個例子：微博切換帳號后會發出一個通知，讓多個界面重新刷新數據。

4）KVO模式
Key-Value-Observer模式也是觀察者模式的一種。KVO的機制為：當指定的被觀察對象的屬性被修改的時候，KVO都會自動的去通知相應的觀察者。舉個例子，在控制器里通過addObserver:forKeyPath:options:context:注冊一個數據源觀察者，當數據源里的數據發生變化時，通過willChangeValueForKey:和didChangeValueForKey:這一對方法發出廣播，控制器收到廣播后就可以利用新的數據來刷新界面。

5）單例模式
通過單例模式可以保證系統中一個類只有一個實例而且該實例易于外界訪問，從而方便對實例個數的控制并節約系統資源。如果希望在系統中某個類的對象只能存在一個，單例模式是最好的解決方案。
單例模式有時也是出于現實邏輯的考慮，比如，一個學校只能有一個校長，校長對象應該就是一個單例對象。雖然從程序的角度你可以初始化多個校長，但這并不符合客觀現實。

3.類變量的@protected ,@private,@public,@package聲明各有什么含義？

答：變量的作用域不同。
@protected 該類和所有子類中 的方法可以直接訪問這樣的變量，這是默認的，
@private 該類中的方法可以訪問這樣的變量，子類不可以。
@public 除了自己和子類方法外，也可以被其他類或者其他模塊中的方法訪問
@package

30. OC的垃圾回收機制?
    　　答案： OC2.0有Garbage collection，但是iOS平臺不提供。
    　　一般我們了解的objective-c對于內存管理都是手動操作的，但是也有自動釋放池。
    　　但是差了大部分資料，貌似不要和arc機制搞混就好了。

31. NSOperation queue?

答案：存放NSOperation的集合類。
操作和操作隊列，基本可以看成java中的線程和線程池的概念。用于處理ios多線程開發的問題。
網上部分資料提到一點是，雖然是queue，但是卻并不是帶有隊列的概念，放入的操作并非是按照嚴格的先進現出。
這邊又有個疑點是，對于隊列來說，先進先出的概念是Afunc添加進隊列，Bfunc緊跟著也進入隊列，Afunc先執行這個是必然的，
但是Bfunc是等Afunc完全操作完以后，B才開始啟動并且執行，因此隊列的概念離亂上有點違背了多線程處理這個概念。
但是轉念一想其實可以參考銀行的取票和叫號系統。
因此對于A比B先排隊取票但是B率先執行完操作，我們亦然可以感性認為這還是一個隊列。
但是后來看到一票關于這操作隊列話題的文章，其中有一句提到
“因為兩個操作提交的時間間隔很近，線程池中的線程，誰先啟動是不定的。”
瞬間覺得這個queue名字有點忽悠人了，還不如pool~
綜合一點，我們知道他可以比較大的用處在于可以幫組多線程編程就好了。

32. 什么是延遲加載?

答案：懶漢模式，只在用到的時候才去初始化。
也可以理解成延時加載。
我覺得最好也最簡單的一個列子就是tableView中圖片的加載顯示了。
一個延時載，避免內存過高，一個異步加載，避免線程堵塞。

33. 是否在一個視圖控制器中嵌入兩個tableview控制器?

答案：一個視圖控制只提供了一個View視圖，理論上一個tableViewController也不能放吧，只能說可以嵌入一個tableview視圖。當然，題目本身也有歧義，如果不是我們定性思維認為的UIViewController，而是宏觀的表示視圖控制者，那我們倒是可以把其看成一個視圖控制者，它可以控制多個視圖控制器，比如TabbarController那樣的感覺。

34. 一個tableView是否可以關聯兩個不同的數據源?你會怎么處理?

答案：首先我們從代碼來看，數據源如何關聯上的，其實是在數據源關聯的代理方法里實現的。
　　因此我們并不關心如何去關聯他，他怎么關聯上，方法只是讓我返回根據自己的需要去設置如相關的數據源。
　　因此，我覺得可以設置多個數據源啊，但是有個問題是，你這是想干嘛呢?想讓列表如何顯示，不同的數據源分區塊顯示?

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

答案：當數組在程序運行時，需要不斷變化的，使用NSMutableArray，當數組在初始化后，便不再改變的，使用NSArray。需要指出的是，使用NSArray只表明的是該數組在運行時不發生改變，即不能往NSAarry的數組里新增和刪除元素，但不表明其數組內的元素的內容不能發生改變。NSArray是線程安全的，NSMutableArray不是線程安全的，多線程使用到NSMutableArray需要注意。

36. 給出委托方法的實例，并且說出UITableVIew的Data Source方法

答案：CocoaTouch框架中用到了大量委托，其中UITableViewDelegate就是委托機制的典型應用，是一個典型的使用委托來實現適配器模式，其中UITableViewDelegate協議是目標，tableview是適配器，實現UITableViewDelegate協議，并將自身設置為talbeview的delegate的對象，是被適配器，一般情況下該對象是UITableViewController。
UITableVIew的Data Source方法有
-(NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section;
-(UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath;

37. 在應用中可以創建多少autorelease對象，是否有限制?

答案：無

38. 如果我們不創建內存池，是否有內存池提供給我們?

答案:界面線程維護著自己的內存池，用戶自己創建的數據線程，則需要創建該線程的內存池

39. 什么時候需要在程序中創建內存池?

答案：用戶自己創建的數據線程，則需要創建該線程的內存池

40. 類NSObject的那些方法經常被使用?

答案：NSObject是Objetive-C的基類，其由NSObject類及一系列協議構成。其中類方法alloc、class、 description，對象方法init、dealloc、– performSelector:withObject:afterDelay:等經常被使用

41. 什么是簡便構造方法?

答案：簡便構造方法一般由CocoaTouch框架提供，如：
NSNumber的
+numberWithBool:
+numberWithChar:
+numberWithDouble:
+numberWithFloat:
+numberWithInt:
Foundation下大部分類均有簡便構造方法，我們可以通過簡便構造方法，獲得系統給我們創建好的對象，并且不需要手動釋放。

42. 如何使用Xcode設計通用應用?

答案：使用MVC模式設計應用，其中Model層完成脫離界面，即在Model層，其是可運行在任何設備上，在controller層，根據iPhone與iPad(獨有UISplitViewController)的不同特點選擇不同的viewController對象。在View層，可根據現實要求，來設計，其中以xib文件設計時，其設置其為universal。

43. UIView的動畫效果有那些?

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

44. 在iPhone應用中如何保存數據?

答案：有以下幾種保存機制：
　　1.通過web服務，保存在服務器上
　　2.通過NSCoder固化機制，將對象保存在文件中
　　3.通過SQlite或CoreData保存在文件數據庫中

45. 什么是coredata?

答案：coredata是蘋果提供一套數據保存框架，其基于SQlite

46. 什么是NSManagedObject模型?

答案：NSManagedObject是NSObject的子類 ，也是coredata的重要組成部分，它是一個通用的類,實現了core data 模型層所需的基本功能，用戶可通過子類化NSManagedObject，建立自己的數據模型。

47. 什么是NSManagedobjectContext?

答案：NSManagedobjectContext對象負責應用和數據庫之間的交互。

48. 什么是謂詞?

答案：謂詞是通過NSPredicate，是通過給定的邏輯條件作為約束條件，完成對數據的篩選。
predicate = [NSPredicate predicateWithFormat:@"customerID == %d",n];
a = [customers filteredArrayUsingPredicate:predicate];

49. 和coredata一起有哪幾種持久化存儲機制?

答案：存入到文件、 存入到NSUserDefaults(系統plist文件中)、存入到Sqlite文件數據庫

50. 談談對Block 的理解?并寫出一個使用Block執行UIVew動畫?

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

51. 寫出上面代碼的Block的定義。

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

52. 試著使用+ beginAnimations:context:以及上述Block的定義，寫出一個可以完成
    +(void)transitionWithView:(UIView *)view duration:(NSTimeInterval)duration options:(UIViewAnimationOptions)options animations:(void (^)(void))animations completion:(void (^)(BOOL finished))completion NS_AVAILABLE_IOS(4_0);操作的函數執行部分

答案：無
網絡部分

53. 做過的項目是否涉及網絡訪問功能，使用什么對象完成網絡功能?

答案：ASIHTTPRequest與NSURLConnection

54. 簡單介紹下NSURLConnection類及+ sendSynchronousRequest:returningResponse:error:與– initWithRequest:delegate:兩個方法的區別?

答案: NSURLConnection主要用于網絡訪問，其中+ sendSynchronousRequest:returningResponse:error:是同步訪問數據，即當前線程會阻塞，并等待request的返回的response，而– initWithRequest:delegate:使用的是異步加載，當其完成網絡訪問后，會通過delegate回到主線程，并其委托的對象。

55. 多線程是什么

多線程是個復雜的概念，按字面意思是同步完成多項任務，提高了資源的使用效率，從硬件、操作系統、應用軟件不同的角度去看，多線程被賦予不同的內涵，對于硬件，現在市面上多數的CPU都是多核的，多核的CPU運算多線程更為出色;從操作系統角度，是多任務，現在用的主流操作系統都是多任務的，可以一邊聽歌、一邊寫博客;對于應用來說，多線程可以讓應用有更快的回應，可以在網絡下載時，同時響應用戶的觸摸操作。在iOS應用中，對多線程最初的理解，就是并發，它的含義是原來先做燒水，再摘菜，再炒菜的工作，會變成燒水的同時去摘菜，最后去炒菜。

56. iOS 中的多線程

iOS中的多線程，是Cocoa框架下的多線程，通過Cocoa的封裝，可以讓我們更為方便的使用線程，做過C++的同學可能會對線程有更多的理解，比如線程的創立，信號量、共享變量有認識，Cocoa框架下會方便很多，它對線程做了封裝，有些封裝，可以讓我們創建的對象，本身便擁有線程，也就是線程的對象化抽象，從而減少我們的工程，提供程序的健壯性。
GCD是(Grand Central Dispatch)的縮寫 ：
從系統級別提供的一個易用地多線程類庫，具有運行時的特點，能充分利用多核心硬件。GCD的API接口為C語言的函數，函數參數中多數有Block，關于Block的使用參看這里，為我們提供強大的“接口”，對于GCD的使用參見本文
NSOperation與Queue
NSOperation是一個抽象類，它封裝了線程的細節實現，我們可以通過子類化該對象，加上NSQueue來同面向對象的思維，管理多線程程序。具體可參看這里：一個基于NSOperation的多線程網絡訪問的項目。
NSThread
NSThread是一個控制線程執行的對象，它不如NSOperation抽象，通過它我們可以方便的得到一個線程，并控制它。但NSThread的線程之間的并發控制，是需要我們自己來控制的，可以通過NSCondition實現。
參看 iOS多線程編程之NSThread的使用
其他多線程
在Cocoa的框架下，通知、Timer和異步函數等都有使用多線程，(待補充).

57. 在項目什么時候選擇使用GCD，什么時候選擇NSOperation?

項目中使用NSOperation的優點是NSOperation是對線程的高度抽象，在項目中使用它，會使項目的程序結構更好，子類化NSOperation的設計思路，是具有面向對象的優點(復用、封裝)，使得實現是多線程支持，而接口簡單，建議在復雜項目中使用。
項目中使用GCD的優點是GCD本身非常簡單、易用，對于不復雜的多線程操作，會節省代碼量，而Block參數的使用，會是代碼更為易讀，建議在簡單項目中使用。

58. 什么是block

對于閉包(block),有很多定義，其中閉包就是能夠讀取其它函數內部變量的函數，這個定義即接近本質又較好理解。對于剛接觸Block的同學，會覺得有些繞，因為我們習慣寫這樣的程序main(){ funA();} funA(){funB();} funB(){…..}; 就是函數main調用函數A，函數A調用函數B… 函數們依次順序執行，但現實中不全是這樣的，例如項目經理M，手下有3個程序員A、B、C，當他給程序員A安排實現功能F1時，他并不等著A完成之后，再去安排B去實現F2，而是安排給A功能F1，B功能F2，C功能F3，然后可能去寫技術文檔，而當A遇到問題時，他會來找項目經理M，當B做完時，會通知M，這就是一個異步執行的例子。在這種情形下，Block便可大顯身手，因為在項目經理M，給A安排工作時，同時會告訴A若果遇到困難，如何能找到他報告問題(例如打他手機號)，這就是項目經理M給A的一個回調接口，要回掉的操作，比如接到電話，百度查詢后，返回網頁內容給A，這就是一個Block，在M交待工作時，已經定義好，并且取得了F1的任務號(局部變量)，卻是在當A遇到問題時，才調用執行，跨函數在項目經理M查詢百度，獲得結果后回調該block。

59. block 實現原理

Objective-C是對C語言的擴展，block的實現是基于指針和函數指針。
從計算語言的發展，最早的goto，高級語言的指針，到面向對象語言的block，從機器的思維，一步步接近人的思維，以方便開發人員更為高效、直接的描述出現實的邏輯(需求)。
下面是兩篇很好的介紹block實現的博文
iOS中block實現的探究
談Objective-C Block的實現

3 block的使用

使用實例
cocoaTouch框架下動畫效果的Block的調用
使用typed聲明block
typedef void(^didFinishBlock) (NSObject *ob);
這就聲明了一個didFinishBlock類型的block，
然后便可用
@property (nonatomic,copy) didFinishBlock finishBlock;
聲明一個blokc對象，注意對象屬性設置為copy，接到block 參數時，便會自動復制一份。
__block是一種特殊類型，
使用該關鍵字聲明的局部變量，可以被block所改變，并且其在原函數中的值會被改變。

4 常見系列面試題

面試時，面試官會先問一些，是否了解block，是否使用過block，這些問題相當于開場白，往往是下面一系列問題的開始，所以一定要如實根據自己的情況回答。
　　1 使用block和使用delegate完成委托模式有什么優點?
　　首先要了解什么是委托模式，委托模式在iOS中大量應用，其在設計模式中是適配器模式中的對象適配器，Objective-C中使用id類型指向一切對象，使委托模式更為簡潔。了解委托模式的細節：
　　iOS設計模式—-委托模式
　　使用block實現委托模式，其優點是回調的block代碼塊定義在委托對象函數內部，使代碼更為緊湊;
　　適配對象不再需要實現具體某個protocol，代碼更為簡潔。
　　2 多線程與block
　　GCD與Block
　　使用 dispatch_async 系列方法，可以以指定的方式執行block
　　GCD編程實例
　　dispatch_async的完整定義
　　void dispatch_async(dispatch_queue_t queue,dispatch_block_t block);
　　功能：在指定的隊列里提交一個異步執行的block，不阻塞當前線程
　　通過queue來控制block執行的線程。主線程執行前文定義的 finishBlock對象
　　dispatch_async(dispatch_get_main_queue(),^(void){finishBlock();});

3.寫一個計算A、B中較大值得標準宏MAX

.#define max(a,b) (((a)>(b))?(a):(b))
.#define MIN(A,B) ((A) <= (B) ? (A) : (B))
MIN(p++, b)會產生宏的副作用
剖析：
這個面試題主要考查面試者對宏定義的使用，宏定義可以實現類似于函數的功能，但是它終歸不是函數，而宏定義中括弧中的“參數”也不是真的參數，在宏展開的時候對“參數”進行的是一對一的替換。程序員對宏定義的使用要非常小心，特別要注意兩個問題：
(1) 謹慎地將宏定義中的“參數”和整個宏用用括弧括起來。所以，嚴格地講，下述解答：
.#define MIN(A,B) (A) <= (B) ? (A) : (B)
.#define MIN(A,B) (A <= B ? A : B )都應判0分；
(2) 防止宏的副作用。
　　宏定義#define MIN(A,B) ((A) <= (B) ? (A) : (B))對MIN(p++, b)的作用結果是：((p++) <= (b) ? (p++) : (b)) 這個表達式會產生副作用，指針p會作兩次++自增操作。除此之外，另一個應該判0分的解答是：#define MIN(A,B) ((A) <= (B) ? (A) : (B));
這個解答在宏定義的后面加“;”，顯示編寫者對宏的概念模糊不清，只能被無情地判0分并被面試官淘汰。

7.類別的作用是什么？說一下類別和類擴展的區別

一.類別（Category）
類別(Category)是一種可以為現有的類（包括類簇:NSString...，甚至源碼無法獲得的類）添加新方法的方式無需從現有的類繼承子類。類別添加的新方法可以被子類繼承。
注：繼承(inheritance)無法為一個類簇創建子類。類別不能添加實例變量。

1. 創建類別
1.1 聲明類別
類別的聲明和類的聲明格式相似：
@interface ClassName(CategoryName)
//method declarations
@end//CategoryName

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

1.2 實現類別

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

2. 類別的作用
類別有以下5個主要作用：
①為現有的類添加新方法；
②將類的實現分散到多個不同文件或多個不同框架中(把一個大的類按功能劃分成幾塊,便于維護)；
③創建對私有方法的前向應用；
④使用category的非正式協議(informal protocol)來實現委托(delegation);
⑤通過替換現有類中的方法，修正現有類(沒有源碼文件的情況下)的功能或錯誤。

2.1 把類按功能劃分成幾塊
UIKIT_CLASS_AVAILABLE(2_0) @interface UIView : UIResponder{
    ................................
}
.................................
@end//UIView


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


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


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


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


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

2.2 委托和類別
委托是類別的一種應用：被發送給委托對象的方法可以聲明為一個NSObject的類別。創建NSObject的類別稱為“創建一個非正式協議”。非正式協議只是一種表達方式，它表示“這里有一些你可能希望實現的方法，當然你也可以不實現這些方法”。示例NSNetService委托方法的部分聲明如下：


@interface NSObject(NSNetServiceBrowserDelegateMethods)


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


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


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


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

2.2.1 如何知道委托對象能否處理發送給它的消息（響應選擇器）
NSNetServiceBrowser首先檢查委托對象，通過NSObject類的respondsToSelector:的方法詢問其能否響應該選擇器。如果委托對象能響應，則NSNetServiceBrowser給委托對象發送消息，反正則不發。
選擇器只是一個方法的名稱，它以Object-C運行時使用的特殊方式編碼，以快速執行查詢。使用@selector(方法名稱)預編譯指令指定選擇器。示例：Car類的setEngine:方法的選擇器是 @selector(setEngine:)
Car類的setTire: atIndex:方法的選擇器是  @selector(setTire: atIndex:)
Car *car = [[Car alloc] init];
if ([car respondsToSelector: @selector(setEngine:)]) {
    return YES;
}

3. 類別的局限性
①無法向現有的類中添加新的實例變量(類別沒有位置容納實例變量)；
②方法名稱沖突，即類別中的新方法的名稱與現有類中方法名稱重名，類別具有更高的優先級，類別中的方法將完全取代現有類中的方法(再也無法訪問現有類中的同名方法)

二、類擴展 （Class Extension也有人稱為匿名分類）
作用：
. 能為某個類附加額外的屬性，成員變量，方法聲明
. 一般的類擴展寫到.m文件中
. 一般的私有屬性寫到類擴展

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

類擴展與分類的區別
* 分類的小括號中必須有名字
@interface 類名（分類名字）
/*方法聲明*/
@end
@implementation 類名（分類名字）
/*方法實現*/
@end
* 分類只能擴充方法，不能擴展屬性和成員變量（如果包含成員變量會直接報錯）。
* 如果分類中聲明了一個屬性，那么分類只會生成這個屬性的set、get方法聲明，也就是不會有實現。
* 舉例說明：如果我們分別在，類擴展與分類中添加了兩個屬性，
// 類別
@interface Mitchell(Mit)
@property (nonatomic, copy) NSString *textOne;
@end

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

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

大家會看到在為在分類中所聲明的屬性textOne賦值的時候，崩潰了，那么我們來查看一下崩潰的原因：
(lldb)po self.textOne
error:property 'textOne' not fount on object of type 'Mitchell *'
意思是說，我們所創建的對象中并沒有textOne這個屬性。也就是說雖然我們再類別中聲明屬性不會報錯，但是@property并沒有自動為我們設置的屬性生成set、get方法。
* 再說一下我們為什么不能包含類的 .m文件，因為這樣會重復包含另一個類的實現文件。
======================================================================
分類category：即使在你不知道一個類的源碼情況下，向這個類添加擴展的方法，并且分類的實現是和其他文件分開的。
#import "Man+SuperMan.h"
@implementation Man （SuperMan）//括號里代表的是分類category的名字
-(void)fly {
NSLog(@"超人起飛了");
}
分類在此的意思是對于Man這個類，在此處添加的方法時額外的，而不是新開的一個類，你不可以在分類的實現文件中為這個類添加額外的成員變量，而在分類文件中，可以通過關鍵字self去調用原類Man的方法，也可以訪問原類的成員變量即使是私有的。而當分類中的方法和原類中的方法同名時，調用時，調用的是分類的方法，相當于分類的方法覆蓋了原類的方法。這又提醒我們，命名方法的時候，一定不要與原類的方法重名。
類擴展（extension）：
1.寫法上與category有些許區別，不需要寫分類名，也就是我們所說匿名類；
2.類擴展的聲明必須在@implementation中實現，也就是說，沒有@implementation的類，例如：framework class是不能使用extension的；
3.extension可以為原類提供新的方法的同時同樣是可以為原有的類添加成員變量，這也就是類擴展比分類好的地方，早在xcode4之后，就已經建議在自定義類的.m文件中使用類擴展，這樣能夠很好的保證代碼的良好的封裝性，進一步避免私有接口的外露。
4.類擴展新增的方法只作用于原類，而不會作用于原類中的子類。