OC self和super

在OC中

1 self是一个指针，在每一个方法中都有一个self指针

2 self可以出现在所有的方法中（对象方法和类方法），不能在函数中

3 self指向调用者。（谁调用它就指向谁）

4 可以使用self->成员变量    访问当前对象内部的成员变量，     没有self.成员变量访问成员变量的

5 当使用self调用方法时，会从当前类的方法列表中开始寻找,如果没有，就从父类中再找,而使用super时,则从父类的方法列表中开始找,然后调用父类的这个方法

6 可以使用[self 方法名] 调用方法 ，或在方法名为setter/getter方法名情况下，可用 self.方法名 调用方法

super的作用

1.直接调用父类中的某个方法

2.super处在对象方法中，那么就会调用父类的对象方法

super处在类方法中，那么就会调用父类的类方法

3.使用场合：子类重写父类的方法时想保留父类的一些行为

开始我们的问题：

@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];

主要是类继承的问题。一个子类从父类继承，获得相关的属性和方法，所以在子类的初始化方法中，必须首先调用父类的初始化方法，以实现父类相关资源的初始化。
[super init]的作用：
面向对象的体现，先利用父类的init方法为子类实例的父类部分进行属性初始化。
调用[super init]时可能会alloc失败，所以我们通过判断self ! =nil 来决定是否执行下面的初始化操作，如果为nil 实例创建失败，终止if内的语句执行。
 在swift中，就不再允许用户去主动调用init来完成对象的创建及初始化，它是通过init构造函数来完成对象的创建。同时在swift中也有类似的“可能失败的构造器”的概念。

下面来看看这个：

@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 的超类开始 寻找。