IOS學習之路--OC的基礎知識

1.項目經驗

2.基礎問題

3.指南認識

4.解決思路

 

 

 ios開發三大塊：

1.Oc基礎

2.CocoaTouch框架

3.Xcode使用

 

--------------------

CocoaTouch

Media

Core Services

Core OS

--------------------

System Framework

 

 

OC的類聲明，定義域

 

OC關鍵字定義爲  @class

O-C特有的語句for（。。in 。。）迭代循環，其餘的條件和循環語句和c同樣

OC對面向對象的概述

（1）基類：NSOject

（2）通常的繼承是單繼承，使用協議@protocol 實現多重繼承

（3）全部的函數都是虛函數

Id類型

OC中每一個目標均可以表達爲id類型，泛型。能夠認爲是NSObject *或者 void Nil

  等同於null，表示一個目標指針

類定義

   Oc的類分爲2個文件，

   .h文件存放類，函數的聲明（聲明的關鍵字 @interfance   @end）

   .m文件存放類的具體實現（實現關鍵字）

對象和類的方法

「+」 表示類的方法

「-」表示對象的方法  -（int）返回值f 函數的名字: (int)  x;參數（有個「：」表示有幾個參數，從第二個參數起「：」前面必須加空格）

對於方法聲明的講解

「：」表示繼承 @interface  Dog : NSObject{}  @end

「{}」之間只能寫字段(如：int age)，不能寫函數

右括號和@end間接寫的是函數

建立對象

  Dog *dog=[Dog alloc] ;  一個類的名字 + alloc

初始化構造函數

   [dog init];　　　　凡是以init…開頭的都是構造函數

銷燬對象

[dog release];

字段定義

三種做用域：@public @protected（保護，在類自己或者子類中） @private （只能在類的內部）

補充：缺省的是protected

函數所有用public

變量必須定義在類{}之間的地方

注：在c中函數和字段是能夠重名的

類的聲明

  必須帶「*」 即表示指針也表示引用   Dog（對象） * myDog （變量名）

訪問 myDog.dog（變量名訪問字段）或者使用空格       

多參數方法

 帶兩個參數（函數名爲f::）

  兩種寫法  -（float）f(int)x 【空格】 :(int)y           不提倡這種寫法

（2）-（float）f(int)x  【空格】g:(int)y  g:表示標籤   （第一參數不能有標籤，第一個函數名就至關於第一個參數的標籤，是爲了方便閱讀）

如何調用方法

無參數

-（int）foo;

  Int ret=[obj foo] 調obj的方法，沒有參數，調方法的時候用[]

一個參數

-（int）foo:(int)a;

Int ret=[obj foo:10]

帶標籤

-（int）foo:(int)a   andB(int)b;

Int ret=[obj foo:10  andB:2];

OC不是嚴格的函數重載

-（int）g:(int)x;

-（int）g:(folat)x;兩個函數的函數名都爲」g:」 在OC中是錯誤的，可是c中是可行  

函數做用域聲明

.h中定義的全部函數都是public類型的

私有化的解決方法

在.m文件中使用Categories

 

@property  age

合成定義在.h文件中使用  編譯器

=（1）」-（void）setAge:（int）newAge;」 + 「-(int) age;」

@synthesize  合成實現，編譯器自動實現getter和setter函數

 =（1）」-（void）setAge:(int)newAge{ age = newAge;}」+」return age;」

屬性能夠是

readwrite（缺省），readonl：

表示可讀寫（setter和getter函數均可以使用），readonly只能用getter

assign（缺省）、retain，copy

表示屬性如何存儲  assign至關於「=」表示賦值

Nonatomic（UI中經常使用）

表示不用考慮線程安全問題

getter=…,setter=…

從新設置getter函數和setter函數名

 

點語法

 

內部類age和點age（.age）不一樣

直接訪問age至關於訪問age字段，

.age在等號左邊至關於setter函數，在等號的右邊至關於getter函數

例子：dog.age=200；展開成[dog setAge:200]; 

 

說明：

（1）age不是變量的名字，而是函數

（2）點語法在等號的左邊表示設置函數（set…）

dogAge = dog.age;展開成 dogAge = [dog age];  （系統自動展開）

 

@class 與 #import :

import會包含這個類的全部信息，包括實體變量和方法，

而@class只是告訴編譯器，其後面聲明的名稱是類的名稱

 

在頭文件中， 通常只須要知道被引用的類的名稱就能夠了。 不須要知道其內部的實體變量和方法，

因此在頭文件中通常使用@class來聲明這個名稱是類的名稱。

 

而在實現類裏面，由於會用到這個引用類的內部的實體變量和方法，

因此須要使用#import來包含這個被引用類的頭文件。

 

在編譯效率方面考慮，若是你有100個頭文件都#import了同一個頭文件，或者這些文件是依次引用的，

如A–>B, B–>C, C–>D這樣的引用關係。當最開始的那個頭文件有變化的話，後面全部引用它的類都須要從新編譯，

若是你的類有不少的話，這將耗費大量的時間。而是用@class則不會。

 

若是有循環依賴關係，如:A–>B, B–>A這樣的相互依賴關係，若是使用#import來相互包含，那麼就會出現編譯錯誤，

若是使用@class在兩個類的頭文件中相互聲明，則不會有編譯錯誤出現。

 

因此，通常來講，@class是放在interface中的，只是爲了在interface中引用這個類，把這個類做爲一個類型來用的。

在實現這個接口的實現類中，若是須要引用這個類的實體變量或者方法之類的,仍是須要import在@class中聲明的類進來.

 

 

字符串

 

NSString： Cocoa中處理字符串的類

NSString型數據是特殊的NSString字面量，其指示標誌是雙引號內的字符串前的@，如@「Hi！」

NSString的stringWithFormat：方法就是經過格式字符串和參數來建立NSString的

+（id）stringWithFormat：（NSString *）format，...;

例子：

NSString *height；

Height=[NSString stringWithFormat:@」Your height is %d feet,%d inches」,5,11];

stringWithForat：（1）定義最後的省略號：能夠接受對個以逗號隔開的其餘參數

（2）「+」修飾的方法，爲類方法，這個方法屬於類對象（而不是類的實例對象）而且一般用於建立新的實例

是一個工廠方法，根據提供的參數建立新對象

「-」建立的大部分方法都是實例方法

NSString的實例方法length。返回的是字符串中的字符個數

使用 -（unsigned int）length：

    Unsigned int length=[height length]；

If（[height length]>35）{

NSLog(@」wow,you’re relly  tall!」)}

比較字符串               

      isEqualToString：能夠用來比較接收方和當作參數傳遞來的字符串。返回一個BOOL型數據表示字符串的內容是否相同，

-（BOOL）isEqualToString：（NSString *）aString；

具體的使用方法:

NSString *thing1=@「hello 5」；

NSString *thing2;

Thing2=[NSString stringWithFormat:@「hello %d」,5];

If([thing1 isEqualToString:thing2]){ NSLog(@」They are  the same!);

注意：「==「運算符只判斷thing1和thing2的這真數值，而不是他們所指的對象

兩個字符串是否相等（等價性，兩個字符串是否表明同一個事物）用isEqualToString

Compare:（區分大小寫的比較的字符逐個字符的進行比較，，返回一個NSComparisonResult（就是一個enum型數據）來顯示比較結果。如返回值是NSOrderedAscending，那麼左側的數值就小右側的數值，即compare的目標在字母表中的排序位置比傳遞進來的字符串更靠前

Compare：options：

例子：-（NScomparisonResult）compare：（NSString *）string

                           options：（unsigned）mask；

options參數是一個位掩碼。能夠使用位或（bitiwise-OR）運算符（|）來添加選項標記。經常使用的選項以下：

NSCaseInsensitiveSearch：不區分大小寫字符

NSLiteralSearch：進行徹底比較，區分大小寫

NSNumericSearch：比較字符串的字符個數，而不是字符值，

可變數組

與NSString同樣NSArray建立的是不可變對象的數組。補充類NSMutableArray，能夠隨意的田間和刪除數組，經過類方法arrayWithCapacity來建立新的可變數組

+（id）arrayWithCapacity：（unsignde）numltems

刪除特定索引處德對象。removeObject

 

枚舉

NSEnumerator是Cocoa用來描述集合迭代運算的方式，需經過objectEnumerator像組組請求枚舉器

-（NSEnumerator *）objcetEnumerator

從後向前瀏覽集合 reverseObjectEnumerator

能夠用while循環，每次循環都向枚舉器請求他的nextObject（下一個對象）

-（id）nextObject;返回nil時，循環結束

注：不能經過添加或刪除對象這類方式來改變

 

 

字典：NSDictionary（也成爲散列表或關聯類表）使用的是鍵查詢的優化存儲方式

就是關鍵字及其定義的集合

NSDictionary在給定的關鍵字（一般是一個NSString字符串）下存儲一個數值（能夠是任何類型的對象

與NSString和NSArray同樣只能使用NSMutableDictionary添加或者刪除

建立字典dictionaryWithObjectsAndKeys；

    +（id）dictionaryWithObjectsAndKeys：

          （id）firstObject，…;

objectForKey:獲取字典中得值，向方法傳遞以前用來存儲改制的關鍵字

  -（id）objectForKey：（id）aKey；

添加元素

-（void）setObject:forkey

 

NSNumber類來包裝（即以對象形式實現）基本數據類型：

建立NSNumber對象：

+（NSNumber *）numberWithChar：(char)  value;

+（NSNumber *）numberWithint：（int）value；

+（NSNumber *）numberWithFolatr （float） value；

+（NSNumber *）numberWithBOOL  （BOOL） value;

 

 

對初學者來講，Objective-C存在了不少使人費解的寫法，實際上他們是很是優雅的。

程序員寫的最多的就是函數以及調用本身寫的或者別人寫的函數。本文就從函數的角度來看下Objective-C的優雅之處。

C#和Objective-C同屬於c系列語言。讓咱們先看下C#的函數定義和調用，作個對比。

C#函數的定義：

public void doIt(string actorName, string movieName, int timesSeen)
        {
            Console.Write("{0} is my favorite actor in the movie {1}, I saw it {2} times.", actorName, movieName, timesSeen);
        }

函數的調用：

Class1 objMovie = new Class1();
            objMovie.doIt("萊昂納多·迪卡普里奧", "盜夢空間", 120);

在讓.net程序員看下Objective-C的定義：

- (void) doIt:(NSString *) actorName movieName: (NSString*) value timesSeen: (int)times {
                NSLog(@"%@ is my favorite actor in the movie %@, I saw it %i times.",actorName, value, times);
          }

若是你第一次看Objective-C，確定會琢磨不透上面的代碼，懷疑是否是寫錯了。

對於上面這個函數的定義：

一、'-'表示這個函數是實例函數（相似非靜態函數），'+'表示這個函數是類函數（相似靜態函數）

二、（void）表示這個函數沒有返回值。

三、函數名是'doIt:'，而不是'doIt'

四、參數用空格隔開

五、參數類型寫在括號中

六、參數份內部參數和外部參數，如電影名稱，內部參數是：value，外部參數是：movieName

七、函數的一個參數沒有外部參數的名稱，有內部參數名。如：actorName。

調用：

從上面代碼能夠看出除了第一個參數，其他的參數均可以加上外部參數名稱用於區別。

從上面能夠看出Objective-C和C#區別很大，實在會令.net程序員費解。Objective-C函數設計的優雅之處在於即有內部參數名又有外部參數名，能夠不用在再內部定義變量來存放函數的參數。

對Objective-C函數學習的一個簡單總結。

 

 

• 運行過程

1.編寫OC程序：.m源文件

2.編譯.m文件爲.o目標文件：cc -c xxxx.m

3.連接.o文件爲a.out可執行文件：cc xxxx.o -framework Foundation

4.執行a.out文件：./a.out

• #import 的功能跟#include同樣，只是更好用，他避免了頭文件的屢次包含
• 爲了能使用OC的特性， 必定要引入#import <Foundation/Foundation.h>

•  類定義// @implementation 和 @end

 

// 設計（定義）一個車類
// @implementation 和 @end
// : NSObject ：讓Car這個類具有建立對象的能力（繼承）
@implementation Car : NSObject
// 這個大括號裏面只能寫全部的屬性
{
    // @public：讓對象的屬性能夠被外面的指針訪問,默認是私有的
    @public
    int wheels; // 默認基本數據類型的初始值都是0
}

// 在@end的前面，大括號{}外面寫行爲
// 給Car對象增長一個行爲（方法）
// 給對象增長一個行爲，必須以減號 - 開頭， 給類增長一個對象是+。
// OC方法中的小括號()只是主要擴住類型
- (void) run
{
    // 訪問車子對象內部的屬性，直接用屬性名就能夠
    NSLog(@"%i個輪子，%f時速的車子跑起來了！", wheels, speed);
}
+ (Void) test
{
    // 這是類方法。上面那個-號的是對象方法。
}

@end

 

 

 

•  類調用

    // 在OC中想執行一些行爲，首先寫個 [行爲執行者  行爲名稱]
    
    // new這個行爲執行完畢後，會返回這個對象的地址
    Car *c = [Car new];
    // 給c指向的車子對象的wheels屬性賦值
    c->wheels = 4; // 等價於 (*c).wheels = 4
    
    // 給指針變量c指向的對象「發送」一條run消息，讓這個對象執行run這個行爲
    [c run];

•  聲明&實現

// 聲明一個類
/*
 1.類名
 2.繼承了NSObject
 3.聲明屬性
 4.聲明方法（僅僅是聲明，不須要實現）
 5.實現和聲明中的成員變量不能同名
 */
@interface Book : NSObject
{　　
    @public
    double price;// 這些屬性稱爲對象的「成員變量」
}

// 聲明一個方法（行爲）
- (void)reng;

@end

// 定義(實現)一個類
/*
 只用來實現@interface中聲明的方法
 */
@implementation Book 

- (void)reng
{
    NSLog(@"%f的書被扔了！", price);
}

•  多參數的聲明和使用

- (void) fly
{
    NSLog(@"i can fly, my age is %d", age);
}

// 一個參數對應一個冒號
// 冒號也是方法名的一部分
- (void)fly:(int)howHeight
{
    NSLog(@"i can fly, my age is %d, my height %d", age, howHeight);
}

// 多個參數的狀況。  withTime是方法名的一部分.times是參數名稱
- (void)fly:(int)howHeight :WithTime(int)times
{
}

    Person *p = [Person new];
    [p fly];
    [p fly:99];
    [p fly:99 WithTime:10];

•  OC對象方法和函數的區別

　　1. 函數屬於整個文件，在文件的任意地方都能調用；對象的方法只屬於這個對象，只有對象才能調用

　　2. 對象的方法只能聲明在@infterface 和@end 之間，對象方法只能實如今@implementation 和@end之間。

　　　函數的聲明和定義能夠寫在任意地方，函數不能歸某個類全部，只屬於某個文件。

• 消息機制

　　給指針變量所指向的對象發送一條消息（消息名稱就是方法名），讓那個對象執行相應的方法（動態）

 

 

 

iOS求職之OC面試題

一、Objective-C的類能夠多重繼承麼？能夠採用多個協議麼？

答：不能夠多重繼承，能夠採用多個協議。

二、#import和#include的區別是什麼？＃import<> 跟 #import""有什麼區別？

#import能避免頭文件被重複包含的問題:

1） 通常來講，導入objective c的頭文件時用#import，包含c/c++頭文件時用#include。

使用include要注意重複引用的問題：

class A，class B都引用了class C，class D若引用class A與class B,就會報重複引用的錯誤。

2）#import 肯定一個文件只能被導入一次，這使你在遞歸包含中不會出現問題。

因此，#import比起#include的好處就是它避免了重複引用的問題。因此在OC中咱們基本用的都是import。

＃import<> 包含iOS框架類庫裏的類，#import""包含項目裏自定義的類。

 

三、Category是什麼？擴展一個類的方式用繼承好仍是類目好？爲何？

答：Category是類目。用類目好，由於繼承要知足a is a b的關係，而類目只須要知足a has a b的關係，侷限性更小，你不用定義子類就能擴展一個類的功能，還能將類的定義分開放在不一樣的源文件裏, 用Category去重寫類的方法，僅對本Category有效，不會影響到其餘類與原有類的關係。

 

四、延展是什麼？做用是什麼？

答：延展（extension）:在本身類的實現文件中添加類目來聲明私有方法。

五、類實例（成員）變量的@protected,@private,@public聲明各有什麼含義？

@protected：受保護的，該實例變量只能在該類和其子類內訪問，其餘類內不能訪問。

@private：私有的，該實例變量只能在該類內訪問，其餘類內不能訪問。

@public：共有的，該實例變量誰均可以訪問。

六、id聲明的對象有什麼特性？

Ø  沒有 * 號

Ø  動態數據類型

Ø  能夠指向任何類的對象(設置是nil)，而不關心其具體類型

Ø  在運行時檢查其具體類型

Ø  能夠對其發送任何（存在的）消息

七、委託是什麼？委託和委託方雙方的property聲明用什麼屬性？爲何？

委託：一個對象保存另一個對象的引用，被引用的對象實現了事先肯定的協議，該協議用於將引用對象中的變化通知給被引用對象。

委託和委託方雙方的property聲明屬性都是assign而不是retain

爲了不循環引用形成的內存泄露。

      循環引用的問題這樣理解：

       好比在main函數中建立了兩個類的對象A和B，如今引用計數都是1。如今讓A和B互相引用(A有一個屬性是B對象，屬性說明是retain；B有一個屬性是A對象，屬性說明是retain)，如今兩個對象的引用計數都增長了1，都變成了2。

  如今執行[A release]; [B release]; 此時建立對象的main函數已經釋放了本身對對象的全部權，可是此時A和B的引用計數都仍是1，由於他們互相引用了。

  這時你發現A和B將沒法釋放，由於要想釋放A必須先釋放B，在B的dealloc方法中再釋放A。同理，要想釋放B必須先釋放A，在A的dealloc方法中再釋放B。因此這兩個對象將一直存在在內存中而不釋放。這就是所謂的循環引用的問題。要想解決這個問題，通常的方法能夠將引用的屬性設置爲assign,而不是retain來處理。

八、淺拷貝和深拷貝區別是什麼？

       淺層複製：只複製指向對象的指針，而不復制引用對象自己。

深層複製：複製引用對象自己。

意思就是說我有個A對象，複製一份後獲得A_copy對象後，對於淺複製來講，A和A_copy指向的是同一個內存資源，複製的只不過是是一個指針，對象自己資源仍是隻有一份，那若是咱們對A_copy執行了修改操做,那麼發現A引用的對象一樣被修改，這其實違背了咱們複製拷貝的一個思想。深複製就好理解了,內存中存在了兩份獨立對象自己。

用網上一哥們通俗的話將就是：

淺複製比如你和你的影子，你完蛋，你的影子也完蛋

深複製比如你和你的克隆人，你完蛋，你的克隆人還活着。

九、內存管理的幾條原則是什麼？按照默認法則，哪些關鍵字生成的對象須要手動釋放？哪些狀況下不須要手動釋放，會直接進入自動釋放池？

•       當使用new、alloc或copy方法建立一個對象時，該對象引用計數器爲1。若是不須要使用該對象，能夠向其發送release或autorelease消息，在其使用完畢時被銷燬。

•       若是經過其餘方法獲取一個對象，則能夠假設這個對象引用計數爲1，而且被設置爲autorelease，不須要對該對象進行清理，若是確實須要retain這個對象，則須要使用完畢後release。

•       若是retain了某個對象，須要release或autorelease該對象，保持retain方法和release方法使用次數相等。

 

使用new、alloc、copy關鍵字生成的對象和retain了的對象須要手動釋放。設置爲autorelease的對象不須要手動釋放，會直接進入自動釋放池。

 

十、怎樣實現一個單例模式的類，給出思路，不寫代碼。

•       首先必須建立一個全局實例，一般存放在一個全局變量中,此全局變量設置爲nil

•       提供工廠方法對該全局實例進行訪問，檢查該變量是否爲nil，若是nil就建立一個新的實例，最後返回全局實例

•       全局變量的初始化在第一次調用工廠方法時會在+allocWithZone:中進行，因此須要重寫該方法，防止經過標準的alloc方式建立新的實例

•       爲了防止經過copy方法獲得新的實例，須要實現-copyWithZone方法

•       只需在此方法中返回自己對象便可，引用計數也不須要進行改變，由於單例模式下的對象是不容許銷燬的，因此也就不用保留

•       由於全局實例不容許釋放，因此retain,release,autorelease方法均需重寫

十一、@class的做用是什麼？

答：在頭文件中， 通常只須要知道被引用的類的名稱就能夠了。 不須要知道其內部的實體變量和方法，因此在頭文件中通常使用@class來聲明這個名稱是類的名稱。 而在實現類裏面，由於會用到這個引用類的內部的實體變量和方法，因此須要使用#import來包含這個被引用類的頭文件。

•       @class的做用是告訴編譯器，有這麼一個類，用吧，沒有問題

•       @class還能夠解決循環依賴的問題，例如A.h導入了B.h，而B.h導入了A.h，每個頭文件的編譯都要讓對象先編譯成功才行

•       使用@class就能夠避免這種狀況的發生

十二、KVC是什麼?KVO是什麼?有什麼特色？

•       KVC是鍵值編碼，特色是經過指定表示要訪問的屬性名字的字符串標識符，能夠進行類的屬性讀取和設置

•       KVO是鍵值觀察，特色是利用鍵值觀察能夠註冊成爲一個對象的觀察者，在該對象的某個屬性變化時收到通知

1三、MVC是什麼？有什麼特性？

–      MVC是一種設計模式，由模型、視圖、控制器3部分組成。

–      模型：保存應用程序數據的類，處理業務邏輯的類

–      視圖：窗口，控件和其餘用戶能看到的而且能交互的元素

–      控制器：將模型和試圖綁定在一塊兒，肯定如何處理用戶輸入的類

1四、定義屬性時，什麼狀況使用copy、assign、retain？

使用assign: 對基礎數據類型 （NSInteger，CGFloat）和C數據類型（int, float,double, char, 等等）

使用copy： 但願得到源對象的副本而不改變源對象內容時，對NSString

使用retain： 但願得到源對象的全部權時，對其餘NSObject和其子類

 

15.屬性readwrite，readonly，assign，retain，copy，nonatomic 各是什麼做用，在那種狀況下用？

assign用於簡單數據類型，如NSInteger,double,bool,

retain和copy用於對象，

readwrite是可讀可寫特性；須要生成getter方法和setter方法時

readonly是隻讀特性  只會生成getter方法 不會生成setter方法 ;不但願屬性在類外改變

assign是賦值特性，setter方法將傳入參數賦值給實例變量；僅設置變量時；

retain表示持有特性，setter方法將傳入參數先保留，再賦值，傳入參數的retaincount會+1;

copy表示賦值特性，setter方法將傳入對象複製一份；須要徹底一份新的變量時。

nonatomic非原子操做，決定編譯器生成的setter getter是不是原子操做，atomic表示多線程安全，通常使用nonatomic

 

16.id 聲明的對象有什麼特性？

答：Id聲明的對象具備運行時的特性，便可以指向任意類型的objcetive-c的對象；

 

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

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

 

18.內存管理的幾條原則時什麼？

誰申請，誰釋放

遵循Cocoa Touch的使用原則；

內存管理主要要避免「過早釋放」和「內存泄漏」，對於「過早釋放」須要注意@property設置特性時，必定要用對特性關鍵字，對於「內存泄漏」，必定要申請了要負責釋放，要細心。

 

19.那些關鍵字生成的對象 須要手動釋放？

答：關鍵字alloc 或new 生成的對象須要手動釋放

 

20在和property結合的時候怎樣有效的避免內存泄露？

答：設置正確的property屬性，對於retain須要在合適的地方釋放

 

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

Profile-> Instruments ->Time Profiler

22.Object－c的類能夠多重繼承麼？能夠實現多個接口麼？

答：Object-c的類不能夠多重繼承；能夠實現多個接口，經過實現多個接口能夠完成C++的多重繼承；

 

23.Category是什麼？重寫一個類的方式用繼承好仍是分類好？爲何？

答：Category是類別，通常狀況用分類好，用Category去重寫類的方法，僅對本Category有效，不會影響到其餘類與原有類的關係。

 

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

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

 

25. Object C中建立線程的方法是什麼？若是在主線程中執行代碼，方法是什麼？若是想延時執行代碼、方法又是什麼？

線程建立有三種方法：使用NSThread建立、使用 GCD的dispatch、使用子類化的NSOperation,而後將其加入NSOperationQueue;在主線程執行代碼，方法是 performSelectorOnMainThread，若是想延時執行代碼能夠用performSelector:onThread:withObject:waitUntilDone

 

2六、iPhone5 的屏幕分辨率大小爲  1136＊ 640  ?

答：屏幕分辨率：用於量度位圖圖像內數據量多少的一個參數。一般表示成ppi（每英寸像素Pixel per inch）。屏幕物理尺寸不變，分辨率越高，每單位面積內包含的細節（像素點）越多。

 

2七、struct strA {      int a;     float b;   char c;  } expA;       

   printf("%ld",sizeof(expA));     輸出結果爲  12  ？

       該問題涉及編譯器的「內存對齊」問題：

現代計算機中內存空間都是按照byte（字節）劃分的，從理論上講彷佛對任何類型的變量的訪問能夠從任何地址開始，但實際狀況是在訪問特定變量的時候常常在特定的內存地址訪問，這就須要各種型數據按照必定的規則在空間上排列，而不是順序的一個接一個的排放，這就是對齊。

對齊的做用和緣由：各個硬件平臺對存儲空間的處理上有很大的不一樣。一些平臺對某些特定類型的數據只能從某些特定地址開始存取。其餘平臺可能沒有這種狀況， 可是最多見的是若是不按照適合其平臺的要求對數據存放進行對齊，會在存取效率上帶來損失。好比有些平臺每次讀都是從偶地址開始，若是一個int型（假設爲 32位）若是存放在偶地址開始的地方，那麼一個讀週期就能夠讀出，而若是存放在奇地址開始的地方，就可能會須要2個讀週期，並對兩次讀出的結果的高低 字節進行拼湊才能獲得該int數據。顯然在讀取效率上降低不少。這也是空間和時間的博弈。

一般，咱們寫程序的時候，不須要考慮對齊問題。編譯器會替咱們選擇適合目標平臺的對齊策略。固然，咱們也能夠通知給編譯器傳遞預編譯指令而改變對指定數據的對齊方法。

可是，正由於咱們通常不須要關心這個問題，因此由於編輯器對數據存放作了對齊，而咱們不瞭解的話，經常會對一些問題感到迷惑。最多見的就是struct數據結構的sizeof結果，出乎意料。

       對於結構體來講，按成員中所佔字節最大的是float類型，佔用4個字節，一共有3個成員，因此總的佔用字節爲：4＊ 3 ＝ 12.

       可經過編譯器命令來設定：

      #progma pack (2)   

 

2八、@property語法中readonly/readwrite，atomic/nonatomic的做用，@dynamic的做用？

      @Property：Objective-C語言關鍵詞，與@synthesize配對使用。xcode4.5以及之後的版本，@synthesize能夠省略。

功能：讓編譯器自動編寫一對與數據成員同名的方法聲明來省去讀寫方法的聲明。

聲明property的語法爲：

@property (參數1,參數2) 類型 名字;

如：@property(nonatomic,retain) UIWindow *window;

 

其中參數主要分爲三類：

讀寫屬性： （readwrite/readonly）

setter語意：（assign/retain/copy）

原子性： （atomicity/nonatomic）

 

各參數意義以下：

readwrite：同時產生setter\getter方法

readonly：只產生簡單的getter,沒有setter。

 

assign：默認類型,setter方法直接賦值，而不進行retain操做

retain：setter方法對參數進行release舊值，再retain新值。

copy：setter方法進行Copy操做，與retain同樣

 

atomic：原子性，它沒有一個若是你沒有對原子性進行一個聲明（atomic or nonatomic），那麼系統會默認你選擇的是atomic。

原子性就是說一個操做不能夠被中途cpu暫停而後調度, 即不能被中斷, 要不就執行完, 要不就不執行. 若是一個操做是原子性的,那麼在多線程環境下, 就不會出現變量被修改等奇怪的問題。原子操做就是不可再分的操做，在多線程程序中原子操做是一個很是重要的概念，它經常用來實現一些同步機制，同時也是一些常見的多線程Bug的源頭。固然，原子性的變量在執行效率上要低些。

關於異步與同步：並不是同步就是很差，咱們一般須要同時進行多個操做，這時使用異步，而對於程序來講，通常就是使用多線程，然而咱們不少時候須要在多個線程間訪問共享的數據，這個時候又須要同步來保證數據的準確性或訪問的前後次序。當有多個線程須要訪問到同一個數據時，OC中，咱們能夠使用@synchronized（變量）來對該變量進行加鎖（加鎖的目的經常是爲了同步或保證原子操做）。

nonatomic：非原子性，是直接從內存中取數值，由於它是從內存中取得數據，它並無一個加鎖的保護來用於cpu中的寄存器計算Value，它只是單純的從內存地址中，當前的內存存儲的數據結果來進行使用。在多線環境下可提升性能，但沒法保證數據同步。

 

2九、OSI（Open System Interconnection）開放式系統互聯參考模型 把網絡協議從邏輯上分爲了7層，試列舉常見的應用層協議。

       注意問的是應用層協議，有些同窗直接答了七層模型。

       在開放系統互連(OSI)模型中的最高層，爲應用程序提供服務以保證通訊，但不是進行通訊的應用程序自己。

Telnet協議是TCP/IP協議族中的一員，是Internet遠程登錄服務的標準協議和主要方式。它爲用戶提供了在本地計算機上完成遠程主機工做的能力。

FTP文件傳輸協議是TCP/IP網絡上兩臺計算機傳送文件的協議，FTP是在TCP/IP網絡和INTERNET上最先使用的協議之一，它屬於網絡協議組的應用層。

 

超文本傳輸協議 (HTTP-Hypertext transfer protocol) 是分佈式，協做式，超媒體系統應用之間的通訊協議。是萬維網（world wide web）交換信息的基礎。

SMTP（Simple MailTransfer Protocol）即簡單郵件傳輸協議,它是一組用於由源地址到目的地址傳送郵件的規則，由它來控制信件的中轉方式，它幫助每臺計算機在發送或中轉信件時找到下一個目的地。

時間協議(TIME protocol)是一個在RFC 868內定義的網絡協議。它用做提供機器可讀的日期時間資訊。

DNS 是域名系統 (Domain NameSystem) 的縮寫，是因特網的一項核心服務，它做爲能夠將域名和IP地址相互映射的一個分佈式數據庫。

SNMP(Simple Network ManagementProtocol,簡單網絡管理協議)的前身是簡單網關監控協議(SGMP)，用來對通訊線路進行管理。

TFTP（Trivial FileTransfer Protocol,簡單文件傳輸協議）是TCP/IP協議族中的一個用來在客戶機與服務器之間進行簡單文件傳輸的協議，提供不復雜、開銷不大的文件傳輸服務。端口號爲69。

 

30、網絡傳輸層協議中，基於TCP/IP協議和UDP/IP的鏈接有什麼區別？

TCP：TransmissionControl Protocol 傳輸控制協議TCP是一種面向鏈接（鏈接導向）的、可靠的、基於字節流的運輸層（Transport layer）通訊協議，由IETF的RFC 793說明（specified）。

UDP 是User DatagramProtocol的簡稱， 中文名是用戶數據包協議，是OSI 參考模型中一種無鏈接的傳輸層協議，提供面向事務的簡單不可靠信息傳送服務，IETF RFC 768是UDP的正式規範。

 

面向鏈接：是指通訊雙方在通訊時，要事先創建一條通訊線路，其有三個過程：創建鏈接、使用鏈接和釋放鏈接。電話系統是一個面向鏈接的模式，撥號、通話、掛機；TCP協議就是一種面向鏈接的協議。

面向無鏈接：是指通訊雙方不須要事先創建一條通訊線路，而是把每一個帶有目的地址的包（報文分組）送到線路上，由系統自主選定路線進行傳輸。郵政系統是一個無鏈接的模式，天羅地網式的選擇路線，天女散花式的傳播形式；IP、UDP協議就是一種無鏈接協議。

 

3一、簡述MVC模式中M、V、C分別指代什麼及發揮的做用？

MVC開始是存在於Desktop（桌面）程序中的，M是指數據模型，V是指用戶界面，C則是控制器，使用MVC的目的是將M和V的實現代碼分離。C存在的目的則是確保M和V的同步，一旦M改變，V應該同步更新。

 

視圖是用戶看到並與之交互的界面，視圖沒有真正的處理髮生，無論這些數據是聯機存儲的仍是一個僱員列表，做爲視圖來說，它只是做爲一種輸出數據並容許用戶操縱的方式。

 

模型表示企業數據和業務規則，模型返回的數據是中立的，就是說模型與數據格式無關，這樣一個模型能爲多個視圖提供數據，因爲應用於模型的代碼只需寫一次就能夠被多個視圖重用，因此減小了代碼的重複性。

 

控制器接受用戶的輸入並調用模型和視圖去完成用戶的需求，控制器自己不輸出任何東西和作任何處理。它只是接收請求並決定調用哪一個模型構件去處理請求，而後再肯定用哪一個視圖來顯示返回的數據。

 

 

3二、聲明@property的語法中，retain、copy、assign的含義及做用？試寫出 @property中帶retain和assign關鍵字，經過@synthesize自動生成的的合成存取方法（set、get方法）的實現代碼。

 

getter分析：

@property (nonatomic, retain) test*aTest;

@property (nonatomic, copy) test*aTest;

等效代碼：

-(void)aTest {

    return aTest;

}

 

＝＝＝＝＝＝＝＝＝＝ 貌似我是分割線 ＝＝＝＝＝＝＝＝＝＝＝

@property (retain) test* aTest;

@property (copy) test* aTest;

等效代碼：

-(void)aTest

{

    [aTest  retain];

    return [aTest  autorelease];

}

 

setter分析：

@property (nonatomic, retain) test*aTest;

@property (retain) test* aTest;

等效於：

-(void)setaTest:(test *)newaTest {

    if (aTest !=newaTest) {

       [aTest  release];

       aTest = [newaTest  retain];

    }

}

＝＝＝＝＝＝＝＝＝＝ 貌似我是分割線 ＝＝＝＝＝＝＝＝＝＝＝

@property (nonatomic, copy) test*aTest;

@property (copy) test* aTest;

等效於：

-(void)setaTest:(test *)newaTest {

    if (aTest != newaTest){

       [aTest  release];

       aTest = [newaTest  copy];

    }

}

 

3三、iOS中有哪些回調機制，並做簡單的比較。

各類回調機制的比較：

1）目標動做對：當兩個對象之間有比較緊密的關係時，如視圖控制器與其下的某個視圖。

 

2）代理：也叫委託，當某個對象收到多個事件，並要求同一個對象來處理全部事件時。委託機制依賴於某個協議定義的方法來發送消息。

 

3）通告機制：當須要多個對象或兩個無關對象處理同一個事件時。

 

4）Block：適用於回調只發生一次的簡單任務。

 

3四、列出在編碼中哪些編碼習慣有助於提升代碼質量、軟件性能和健壯性，減小程序崩潰。

＃使用嚴格的命名規則（如匈牙利命名法）可以避免沒必要要的類型轉換錯誤。

＃在編碼前先設計好流程圖或使用僞代碼，清晰化整個設計意圖。

＃對本身的代碼進行嚴格的單元測試（unit testing）。

單元測試是指對軟件中的最小可測試單元進行檢查和驗證。如C語言中單元指一個函數，Java裏單元指一個類，圖形化的軟件中能夠指一個窗口或一個菜單等。總的來講，單元就是人爲規定的最小的被測功能模塊。單元測試是在軟件開發過程當中要進行的最低級別的測試活動，軟件的獨立單元將在與程序的其餘部分相隔離的狀況下進行測試。

＃異常的處理

首先不要輕易使用異常的捕獲，其次要儘量捕獲具體的異常。對於異常的處理最好可以採用封裝的方式，你們統一使用。這樣能夠保證異常處理的一致性也能夠保證當異常出現時性能的穩定。

# 使用內省的方法檢查方法的輸入

＃採用增量式的編程方式。

採用增量式編程和測試，會傾向於建立更小的方法和更具內聚性的類。你應該常常評估代碼質量，並不時的進行許多小調整，而不是一次修改許多東西。在寫了幾行代碼以後，就應該進行一次構建/測試。在沒有獲得反饋時，你不要走的太遠。

 

＃使用工具（如Instrument）來幫助檢查內存泄漏、過早釋放內存、CPU使用效率等問題。

＃消除全部的編譯警告，警告就是錯誤。

＃寫防護性的代碼，使用內省的方法檢查傳入的參數。

 

3五、JSON中{ }表明_____，[ ]表明_____，試將下面的JSON串用OC對象表示出來：

{ "people": [

{ "firstName": "Brett","lastName":"McLaughlin", "email":"aaaa" },

{ "firstName": "Jason","lastName":"Hunter", "email": "bbbb"},

{ "firstName": "Elliotte","lastName":"Harold", "email": "cccc" }

]，

 「location」:」中華人民共和國」

}

 

JSON中{ }表明對象，數據結構爲｛key1:value1, key2:value2, key3:…… ｝

[ ]表明數組，與其餘語言中的數組相似。

//

@interface People: NSObject

 

@property(nonatomic, copy) NSString* strFirstName;

@property(nonatomic, copy) NSString* strLastName;

@property(nonatomic, copy) NSString* strEmail;

 

@end

 

//

@interfaceJSonData : NSObject

 

@property(nonatomic, retain) NSMutableArray* arrPeople;  // 存放People對象

@property(nonatomic, copy) NSString* strLocation;

 

@end

 

36.  Object-C有多繼承嗎？沒有的話用什麼代替？

答：沒有，cocoa 中全部的類都是NSObject 的子類，多繼承在這裏是用protocol 委託代理來實現的
 ，ood的多態特性在obj-c中經過委託來實現。

 

37．bject-C有私有方法嗎？私有變量呢？

objective-c – 類裏面的方法只有兩種, 靜態方法和實例方法.

在類裏面聲名一個私有方法
@interface Controller : NSObject

{ NSString *something;

}
+ (void)thisIsAStaticMethod;
–(void)thisIsAnInstanceMethod;
@end
@interface Controller

(private)

-(void)thisIsAPrivateMethod;
@end

@private能夠用來修飾私有變量
在Objective‐C中，全部實例變量默認都是私有的，全部實例方法默認都是公有的

 

38.  堆和棧的區別？

管理方式：對於棧來說，是由編譯器自動管理，無需咱們手工控制；對於堆來講，釋放工做由程序員控制，容易產生memory leak。

申請大小：棧：棧是向低地址擴展的數據結構，是一塊連續的內存的區域

                   堆：是向高地址擴展的數據結構，是不連續的內存區域。

分配方式：堆都是動態分配的 ，動態分配由alloca函數進行分配 

                   棧的動態分配由編譯器進行釋放，無需咱們手工實現 

39. kvc和kvo的區別？

kvc：鍵值編碼，是一種間接訪問對象的屬性，使用字符串來標示屬性

kvo：鍵值觀察機制，提供了觀察某一屬性變化的方法

 

40. 線程和進程的區別？

答：主要不一樣的是操做系統資源管理方式

線程是一個進程中不一樣的執行路徑，線程有本身的堆、局部變量

進程有獨立的地址空間，一個線程死掉，整個進程就會死掉

 

41.  #import和#include的區別，@class表明什麼？

答：@class通常用於頭文件中須要聲明該類的某個實例變量的時候用到，在m文件中仍是須要使用#import
而#import比起#include的好處就是不會引發重複包含。

 

42. 類別的做用？

答：有時咱們須要在一個已經定義好的類中增長一些方法，而不想去重寫該類。能夠使用類別對該類擴充新的方法。

注意：類別只能擴充方法，而不能擴充成員變量。

   代理的做用

委託代理（degegate），目的是改變和傳遞控制鏈

    顧名思義，把某個對象要作的事情委託給別的對象去作。那麼別的對象就是這個對象的代理，代替它來打理要作的事。反映到程序中，首先要明確一個對象的委託方是哪一個對象，委託所作的內容是什麼。

委託機制是一種設計模式。

多態：子類的指針能夠賦值給父類

 

43．鏈表和數組的區別在哪裏?

兩者都屬於一種數據結構

從邏輯結構來看

1. 數組必須事先定義固定的長度（元素個數），不能適應數據動態地增減的狀況。當數據增長時，可能超出原先定義的元素個數；當數據減小時，形成內存浪費；數組能夠根據下標直接存取。

2. 鏈表動態地進行存儲分配，能夠適應數據動態地增減的狀況，且能夠方便地插入、刪除數據項。（數組中插入、刪除數據項時，須要移動其它數據項，很是繁瑣）鏈表必須根據next指針找到下一個元素

從內存存儲來看

1. (靜態)數組從棧中分配空間, 對於程序員方便快速,可是自由度小

2. 鏈表從堆中分配空間, 自由度大可是申請管理比較麻煩

 

從上面的比較能夠看出，若是須要快速訪問數據，不多或不插入和刪除元素，就應該用數組；相反， 若是須要常常插入和刪除元素就須要用鏈表數據結構了。

 

 

44. main()

 { int a[5]={1,2,3,4,5};   

   int *ptr=(int *)(&a+1);   

  printf("%d,%d",*(a+1),*(ptr-1));

}

答：2,5   *(a+1)就是a[1]，*(ptr-1)就是a[4],執行結果是2，5 　　

&a+1不是首地址+1，系統會認爲加一個a數組的偏移，是偏移了一個數組的大小（本例是5個int） 　　

    int *ptr=(int *)(&a+1);則ptr實際是&(a[5]),也就是a+5

緣由以下：&a是數組指針，其類型爲 int (*)[5];

   而指針加1要根據指針類型加上必定的值，不一樣類型的指針+1以後增長的大小不一樣。　　

   a是長度爲5的int數組指針，因此要加 5*sizeof(int)，因此ptr實際是a[5]，

   可是prt與(&a+1)類型是不同的(這點很重要)，因此prt-1只會減去sizeof(int*)　　

    a,&a的地址是同樣的，但意思不同    

    a是數組首地址，也就是a[0]的地址，&a是對象（數組）首地址，         a+1是數組下一元素的地址，即a[1],&a+1是下一個對象的地址，即a[5].

 

45. 寫一個委託的interface

@protocol MyDelegate;

@interface MyClass: NSObject

{    id <MyDelegate> delegate; }

//委託方法@protocol MyDelegate- (void)didJobs:(NSArray *)args;

@end

 

46. 寫一個NSString類的實現

+(id)initWithCString:(const char *)nullTerminatedCStringencoding:(NSStringEncoding)encoding;

+ (id)stringWithCString: (const char*)nullTerminatedCString             encoding: (NSStringEncoding)encoding

 {   NSString *obj; 

     obj = [selfallocWithZone: NSDefaultMallocZone()];  

     obj = [objinitWithCString: nullTerminatedCString encoding: encoding];  

     returnAUTORELEASE(obj);

}

 

47. 關鍵字const有什麼含意？修飾類呢?static的做用,用於類呢?還有extern c的做用

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的出現。 

（1）欲阻止一個變量被改變，能夠使用 const 關鍵字。在定義該 const 變量時，一般須要對它進行初 始化，由於之後就沒有機會再去改變它了；（2）對指針來講，能夠指定指針自己爲 const，也能夠指定指針所指的數據爲 const，或兩者同時指 定爲 const；

（3）在一個函數聲明中，const 能夠修飾形參，代表它是一個輸入參數，在函數內部不能改變其值； （4）對於類的成員函數，若指定其爲 const 類型，則代表其是一個常函數，不能修改類的成員變量； （5）對於類的成員函數，有時候必須指定其返回值爲 const 類型，以使得其返回值不爲「左值」。

關鍵字volatile有什麼含意?並給出三個不一樣的例子。一個定義爲volatile的變量是說這變量可能會被意想不到地改變，這樣，編譯器就不會去假設這個變量的值了。精確地說就是，優化器在用到這個變量時必須每次都當心地從新讀取這個變量的值，而不是使用保存在寄存器裏的備份。下面是volatile變量的幾個例子： 

· ;並行設備的硬件寄存器（如：狀態寄存器） 

· ; 一箇中斷服務子程序中會訪問到的非自動變量(Non-automatic variables)

· ; 多線程應用中被幾個任務共享的變量

· ;一個參數既能夠是const還能夠是volatile嗎？解釋爲何。 

· ; 一個指針能夠是volatile 嗎？解釋爲何。 

下面是答案： 

· ; 是的。一個例子是隻讀的狀態寄存器。它是volatile由於它可能被意想不到地改變。它是const由於程序不該該試圖去修改它。 

·; 是的。儘管這並不很常見。一個例子是當一箇中服務子程序修該一個指向一個buffer的指針時。 

static關鍵字的做用：

（1）函數體內 static 變量的做用範圍爲該函數體，不一樣於 auto 變量，該變量的內存只被分配一次，所以其值在下次調用時仍維持上次的值； （2）在模塊內的 static 全局變量能夠被模塊內所用函數訪問，但不能被模塊外其它函數訪問；

（3）在模塊內的 static 函數只可被這一模塊內的其它函數調用，這個函數的使用範圍被限制在聲明 它的模塊內；

（4）在類中的 static 成員變量屬於整個類所擁有，對類的全部對象只有一份拷貝；

（5）在類中的 static 成員函數屬於整個類所擁有，這個函數不接收 this 指針，於是只能訪問類的static 成員變量。

 

extern "C"的做用：

（1）被 extern "C"限定的函數或變量是 extern 類型的；     

 extern是 C/C++語言中代表函數和全局變量做用範圍（可見性）的關鍵字，該關鍵字告訴編譯器，其聲明的函數和變量能夠在本模塊或其它模塊中使用。

（2）被 extern "C"修飾的變量和函數是按照 C 語言方式編譯和鏈接的；

 

extern "C"的慣用法

（1）在 C++中引用 C 語言中的函數和變量，在包含 C 語言頭文件（假設爲 cExample.h）時，需進 行下列處理：

 extern "C"  { #include "cExample.h"   } 

而在 C語言的頭文件中，對其外部函數只能指定爲 extern 類型，C語言中不支持 extern "C"聲明， 在.c 文件中包含了 extern "C"時會出現編譯語法錯誤。

（2）在 C 中引用 C++語言中的函數和變量時，C++的頭文件需添加 extern "C"，可是在 C 語言中不 能直接引用聲明瞭 extern "C"的該頭文件，應該僅將 C 文件中將 C++中定義的extern "C"函數聲明爲 extern 類型。

 

48.爲何標準頭文件都有相似如下的結構？  

 #ifndef __INCvxWorksh    

   #define __INCvxWorksh    

    #ifdef __cplusplus   

    extern "C" {    

     #endif     /*...*/   

      #ifdef __cplusplus    

      }   

  #endif   

  #endif /* __INCvxWorksh */

顯然，頭文件中的編譯宏「#ifndef __INCvxWorksh、#define __INCvxWorksh、#endif」 的做用是防止該頭文件被重複引用。

 

49. #import跟#include的區別,@class呢?

@class通常用於頭文件中須要聲明該類的某個實例變量的時候用到，在m文件中仍是須要使用#import而#import比起#include的好處就是不會引發交叉編譯。

 

50.線程與進程的區別和聯繫?

答：進程和線程都是由操做系統所體會的程序運行的基本單元，系統利用該基本單元實現系統對應用的併發性。

程和線程的主要差異在於它們是不一樣的操做系統資源管理方式。

進程有獨立的地址空間，一個進程崩潰後，在保護模式下不會對其它進程產生影響，而線程只是一個進程中的不一樣執行路徑。

線程有本身的堆棧和局部變量，但線程之間沒有單獨的地址空間，一個線程死掉就等於整個進程死掉，因此多進程的程序要比多線程的程序健壯，但在進程切換時，耗費資源較大，效率要差一些。但對於一些要求同時進行而且又要共享某些變量的併發操做，只能用線程，不能用進程。

 

51.列舉幾種進程的同步機制，並比較其優缺點。

答案：原子操做、信號量機制、自旋鎖、管程、會合、分佈式系統

進程之間通訊的途徑

答案：共享存儲系統消息傳遞系統管道：以文件系統爲基礎

進程死鎖的緣由

答案：資源競爭及進程推動順序非法

死鎖的4個必要條件

答案：互斥、請求保持、不可剝奪、環路

死鎖的處理

答案：鴕鳥策略、預防策略、避免策略、檢測與解除死鎖

 

52.什麼是鍵-值,鍵路徑是什麼

答：模型的性質是經過一個簡單的鍵（一般是個字符串）來指定的。視圖和控制器經過鍵來查找相應的屬性值。在一個給定的實體中，同一個屬性的全部值具備相同的數據類型。鍵-值編碼技術用於進行這樣的查找—它是一種間接訪問對象屬性的機制。

鍵路徑是一個由用點做分隔符的鍵組成的字符串，用於指定一個鏈接在一塊兒的對象性質序列。第一個鍵的性質是由先前的性質決定的，接下來每一個鍵的值也是相對於其前面的性質。鍵路徑使您能夠以獨立於模型實現的方式指定相關對象的性質。經過鍵路徑，您能夠指定對象圖中的一個任意深度的路徑，使其指向相關對象的特定屬性。

For example, the keypath address.streetwould get the value of the address property from thereceivingobject, and then determine the street property relative to the addressobject.

 

53.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.

 

54.目標-動做機制

答：目標是動做消息的接收者。一個控件，或者更爲常見的是它的單元，以插座變量（參見"插座變量"部分） 的形式保有其動做消息的目標。

    動做是控件發送給目標的消息，或者從目標的角度看，它是目標爲了響應動做而實現的方法。程序須要某些機制來進行事件和指令的翻譯。這個機制就是目標-動做機制。

 

55. cocoa touch框架

這些框架包括：

Core Animation

經過Core Animation，您就能夠經過一個基於組合獨立圖層的簡單的編程模型來建立豐富的用戶體驗。

Core Audio

Core Audio是播放，處理和錄製音頻的專業技術，可以輕鬆爲您的應用程序添增強大的音頻功能。

Core Data提供了一個面向對象的數據管理解決方案，它易於使用和理解，甚至可處理任何應用或大或小的數據模型。

   功能列表：框架分類

   下面是 Cocoa Touch 中一小部分可用的框架：

     音頻和視頻

       CoreAudio

       OpenAL

       MediaLibrary

       AVFoundation

     數據管理

       Core Data

       SQLite

     圖形和動畫

       CoreAnimation

       OpenGL ES

       Quartz 2D

      網絡/li>

        Bonjour

        WebKit

        BSDSockets

      用戶應用

        AddressBook

        CoreLocation

        MapKit

        StoreKit

 

56.objc的內存管理

答：若是您經過分配和初始化（好比[[MyClass alloc] init]）的方式來建立對象，您就擁有這個對象，須要負責該對象的釋放。這個規則在使用NSObject的便利方法new 時也一樣適用。

若是您拷貝一個對象，您也擁有拷貝獲得的對象，須要負責該對象的釋放。若是您保持一個對象，您就部分擁有這個對象，須要在再也不使用時釋放該對象。反過來，若是您從其它對象那裏接收到一個對象，則您不擁有該對象，也不該該釋放它（這個規則有少數的例外，在參考文檔中有顯式的說明）。

 

57.自動釋放池是什麼,如何工做？

答：當您向一個對象發送一個autorelease消息時，Cocoa就會將該對象的一個引用放入到最新的自動釋放池。它仍然是個正當的對象，所以自動釋放池定義的做用域內的其它對象能夠向它發送消息。當程序執行到做用域結束的位置時，自動釋放池就會被釋放，池中的全部對象也就被釋放。

1）ojc-c是經過一種"referring counting"(引用計數)的方式來管理內存的, 對象在開始分配內存(alloc)的時候引用計數爲一,之後每當碰到有copy,retain的時候引用計數都會加一, 每當碰到release和autorelease的時候引用計數就會減一,若是此對象的計數變爲了0, 就會被系統銷燬.

2） NSAutoreleasePool就是用來作引用計數的管理工做的,這個東西通常不用你管的.

3）autorelease和release沒什麼區別,只是引用計數減一的時機不一樣而已,autorelease會在對象的使用真正結束的時候才作引用計數減一。

 

58.類工廠方法是什麼？

答：類工廠方法的實現是爲了向客戶提供方便，它們將分配和初始化合在一個步驟中，返回被建立的對象，並進行自動釋放處理。這些方法的形式是+ (type)className...（其中 className不包括任何前綴）。工廠方法可能不只僅爲了方便使用。它們不但能夠將分配和初始化合在一塊兒，還能夠爲初始化過程提供對象的分配信息。類工廠方法的另外一個目的是使類（好比NSWorkspace）提供單件實例。雖然init...方法能夠確認一 個類在每次程序運行過程只存在一個實例，但它須要首先分配一個「生的」實例，而後還必須釋放該實例。工廠方法則能夠避免爲可能沒有用的對象盲目分配內存。

 

59. 單件實例是什麼？

Foundation和Application Kit 框架中的一些類只容許建立單件對象，即這些類在當前進程中的惟一實例。舉例來講，NSFileManager和NSWorkspace 類在使用時都是基於進程進行單件對象的實例化。當向這些類請求實例的時候，它們會向您傳遞單一實例的一個引用，若是該實例還不存在，則首先進行實例的分配和初始化。單件對象充當控制中心的角色，負責指引或協調類的各類服務。若是類在概念上只有一個實例（好比NSWorkspace），就應該產生一個單件實例，而不是多個實例；若是未來某一天可能有多個實例，您能夠使用單件實例機制，而不是工廠方法或函數。

 

60.動態綁定

—在運行時肯定要調用的方法

動態綁定將調用方法的肯定也推遲到運行時。在編譯時，方法的調用並不和代碼綁定在一塊兒，只有在消實發送出來以後，才肯定被調用的代碼。經過動態類型和動態綁定技術，您的代碼每次執行均可以獲得不一樣的結果。運行時因子負責肯定消息的接收者和被調用的方法。運行時的消息分發機制爲動態綁定提供支持。當您向一個動態類型肯定了的對象發送消息時，運行環境系統會經過接收者的isa指針定位對象的類，並以此爲起點肯定被調用的方法，方法和消息是動態綁定的。並且，您沒必要在Objective-C 代碼中作任何工做，就能夠自動獲取動態綁定的好處。您在每次發送消息時，特別是當消息的接收者是動態類型已經肯定的對象時，動態綁定就會例行而透明地發生。

 

61.obj-c的優缺點objc

優勢：  

1) Cateogies   2) Posing   3) 動態識別   4) 指標計算   5）彈性訊息傳遞   6) 不是一個過分複雜的 C 衍生語言   7) Objective-C 與 C++ 可混合編程

缺點:  

1) 不支援命名空間   2)  不支持運算符重載  3） 不支持多重繼承  4） 使用動態運行時類型，全部的方法都是函數調用，因此不少編譯時優化方法都用不到。（如內聯函數等），性能低劣。

 

62.sprintf,strcpy,memcpy使用上有什麼要注意的地方？

答：strcpy是一個字符串拷貝的函數，它的函數原型爲strcpy(char *dst, const char *src);將src開始的一段字符串拷貝到dst開始的內存中去，結束的標誌符號爲'\0'，因爲拷貝的長度不是由咱們本身控制的，因此這個字符串拷貝很容易出錯。

具有字符串拷貝功能的函數有memcpy，這是一個內存拷貝函數，它的函數原型爲memcpy(char *dst,const char* src, unsigned int len);將長度爲len的一段內存，從src拷貝到dst中去，這個函數的長度可控。可是會有內存疊加的問題。

sprintf是格式化函數。將一段數據經過特定的格式，格式化到一個字符串緩衝區中去。sprintf格式化的函數的長度不可控，有可能格式化後的字符串會超出緩衝區的大小，形成溢出。