• 版權聲明：本文為博主原創文章，未經博主允許不得轉載。

這個問題貌似很初級，但很容易讓人忽略，me too 。

面試一定都是很注重基礎的，不管高級還是初級。

雖然基礎好跟基礎不好都可以寫代碼，網上那么多資料。 區分高低也就是研究的深度和廣度。

開始我們的問題：

@implementation Son : Father
- (id)init
{
    self = [super init];
    if (self)
    {
       
    }
    return self;
}```

這段代碼估計很多人都寫爛了,就算沒寫爛，Xcode自動生成的我們也看吐了。 好吧，來說說原來.

上來就是 ： 這個其實就是在子類實現初始化前調用父類的init實現.

這跟沒說一樣，稀里糊涂的。

####首先這個問題，要了解: 
>1, self  是什么 ；super 是什么?
2,[super init] 都做了什么?
3,為什么要 self =  [super init];?

一個一個來：

###1，self  是什么 ，super 是什么

• 在動態方法中，self代表著"對象"

• 在靜態方法中，self代表著"類"

• 萬變不離其宗，記住一句話就行了：self代表著當前方法的調用者

self 和 super 是oc 提供的兩個保留字。 但有根本區別，

self是類的隱藏的參數變量,指向當前調用方法的對象（類也是對象，類對象）,另一個隱藏參數是_cmd，代表當前類方法的selector。

super并不是隱藏的參數,它只是一個"編譯器指示符"```

2, [ super init] 都做了什么

發送消息時:

//Class  A
-reposition  
{  
     ...  
     [self setOrigin:someX :someY];  
     ...  
}```

-  A  a= [a .. init];

- [a  reposition];   //方法體中  編譯器將

[self setOrigin:someX :someY];
其轉換為

objc_msgSend(id self，SEL _cmd, ...) 。self -> a```

此時 self 指代a 對象，方法從a 對應 類結構的 方法調度表中開始尋找，如果找不到，延繼承鏈往父類中尋找 。

同樣如果 reposition 是類方法， self 指代 A 類對象。

//Class  A
-reposition  
{  
     ...  
     [super setOrigin:someX :someY];  
     ...  
}```

- [a  reposition];   方法體中編譯器將

[super setOrigin:someX :someY];
其轉換為

id objc_msgSendSuper(struct objc_super *super, SEL op, ...)```

第一個參數是個objc_super的結構體，第二個參數還是類似上面的類方法的selector，先看下objc_super這個結構體是什么東西：

struct objc_super {
    id receiver;
   Class superClass;
};```

>可以看到這個結構體包含了兩個成員，一個是 receiver，這個類似上面 objc_msgSend 的第一個參數 receiver，第二個成員是記錄寫 super 這個類的父類是什么，拿上面的代碼為例，當編譯器遇到 A 里


- [super setOrigin:someX :someY]時，開始做這幾個事：

      構建 objc_super 的結構體，此時這個結構體的第一個成員變量 receiver 就是 a，和 self 相同。而第二個成員變量 superClass 就是指類 A的 superClass。

      調用 objc_msgSendSuper 的方法，將這個結構體和

>setOrigin的 sel 傳遞過去。函數里面在做的事情類似這樣：從 objc_super 結構體指向的 superClass 的方法列表開始找 setOrigin 的 selector，找到后再以 objc_super->receiver 去調用這個 selector，可能也會使用 objc_msgSend 這個函數，不過此時的第一個參數 theReceiver 就是 objc_super->receiver，第二個參數是從 objc_super->superClass 中找到的 selector.

###3,為什么要 self =  [super init];

>符合oc 繼承類 初始化規范 super 同樣也是這樣，  `[super init]`  去`self` 的super 中調用init ,`super` 調用 superSuper 的init 。直到根類 NSObject 中的init ,

>根類中init 負責初始化 內存區域  向里面添加 一些必要的屬性，返回內存指針，  這樣 延著繼承鏈 初始化的內存指針 被從上 到 下 傳遞，在不同的子類中向塊內存添加 子類必要的屬性，直到 我們的 A 類中 得到內存指針，賦值給slef 參數， 在if (slef){//添加A 的屬性 }

@implementation Son : Father

• (id)init
  {
  self = [super init];
  if (self)
  {
  NSLog(@"%@", NSStringFromClass([self class]));
  NSLog(@"%@", NSStringFromClass([super class]));
  }
  return self;
  }
  @end```

• 應該不難分析出 打印結果：

Son
Son

當 發送 class 消息 時不管是 self 還是 super 其消息主體依然是 self ,也就是說 self 和 super 指向的 是同一個對象。只是 查找方法的位置 區別，一個從本類，一個從本類的超類。
一般情況下 class 方法 只有在 根類 NSObject 中定義，極少情況有子類重寫 class 方法，
所以 [slef class] 和 [super class] 都是在 根類中 找方法實現， 消息接收主體 又都是 a
如果重寫可能會不一樣。
自然都打印出 Son.

• 在來一個例子：

#import <Foundation/Foundation.h>

@interface EngineSuper : NSObject
-(void)printCurrentClass;

@end

#import "EngineSuper.h"

@implementation EngineSuper
-(void)printCurrentClass{

    NSLog(@"EngineSuper=======%@",[self class]);
}
@end



@interface Engine : EngineSuper
-(void)printSupClass;
@end


@implementation Engine

-(void)printSupClass{
   [super printCurrentClass];
}

//調用：
Engine *engine = [[Engine alloc]init];
[engine  printCurrentClass];//直接調用父類 方法，engine沒重載 它

[engine  printSupClass];//間接調用父類方法，

• 打印當然都是 ：

Engine
Engine```

>方法體中` self` 始終指代 方法的接收者 及對象  engine。，
 換成   NSLog(@"EngineSuper=======%@",[super class]); 結果也是`一樣的`。


>`super` 就是個障眼法 發，`編譯器符號`， 它可以替換成 `[slef class]`,只不過 方法是從 self 的`超類`開始 尋找。