Objective-C语言--self和super关键字解析

本文目录

• 一、Java中的this只能用在动态方法中，不能用在静态方法中
• 二、OC中的self既可以用在动态方法中，也可以用在静态方法中

说明：这个Objective-C专题，是学习iOS开发的前奏，也为了让有面向对象语言开发经验的程序员，能够快速上手Objective-C。如果你还没有编程经验，或者对Objective-C、iOS开发不感兴趣，请忽略。学习本专题之前，建议先学习C语言专题。

OC中有一个self关键字，用法跟Java中的this类似，都是代表着当前方法的调用者。但self和this还是有区别的。

回到顶部

一、Java中的this只能用在动态方法中，不能用在静态方法中

1.在动态方法中使用this关键字

1 public class Student {
2     private int age;
3     public void setAge(int age) {
4         this.age = age;
5     }
6 }

在第4行使用了this，这里的this代表着调用setAge方法的某个Student对象

 

2.如果在静态方法中使用this关键字，直接报错

 

回到顶部

二、OC中的self既可以用在动态方法中，也可以用在静态方法中

1.self在动态方法中

 1 @implementation Student
 2 
 3 - (void)test2 {
 4 
 5 }
 6 
 7 - (void)test3 {
 8     [self test2];
 9 }
10 
11 @end

* 在第3行、第8行定义了2个动态方法

* 在第8行使用了self关键字，这里的self代表着调用test3方法的某个Student对象

* 第8行代码的作用是调用Student对象的动态方法test2

 

2.self在静态方法中

 1 @implementation Student
 2 
 3 + (void)test2 {
 4 
 5 }
 6 
 7 + (void)test3 {
 8     [Student test2];
 9     
10     [self test2];
11 }
12 
13 @end

* 在第3、第7行定义了2个静态方法，看清楚方法前面的+号

* 再看第10行，这里用到了self。看清楚了，是在静态方法test3中用到了self关键字

* 一开始就说了，self代表着当前方法的调用者。当前方法是test3，那test3的调用者是谁呢？肯定是Student这个类，因为test3是个静态方法。因此这里的self代表着Student这个类

* 因此，第8行、第10行的作用是一样，都是调用了静态方法test2

 

3.self总结

1> 在动态方法中，self代表着"对象"

2> 在静态方法中，self代表着"类"

3> 万变不离其宗，记住一句话就行了：self代表着当前方法的调用者

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

@implementation Son : Father
- (id)init{

    self = [super init];
    if (self){
    }
    return self;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

这是一个普通到初始化方法， 子类实现初始化前调用父类的init实现。基于这个初始化方法，我们从三个方面来对比self和super关键字。

self是什么，super是什么？

在动态方法中:self代表着”对象”; 
在静态方法中:self代表着”类”; 
一句话总结就是：self代表着当前方法的调用者;

self 和 super 是Objective-C提供的两个保留字。 但有根本区别，self是类的隐藏的参数变量,指向当前调用方法的对象（类也是对象，类对象）,另一个隐藏参数是_cmd，代表当前类方法的selector。super并不是隐藏的参数,它只是一个”编译器指示符”。

[ super init] 做了什么。

发送消息时

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

• 1
• 2
• 3
• 4
• 5
• 6

• 1
• 2
• 3
• 4
• 5
• 6

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];  
     ...  
}

• 1
• 2
• 3
• 4
• 5
• 6

• 1
• 2
• 3
• 4
• 5
• 6

[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

为什么要 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

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

应该不难分析出 打印结果：

Son 
Son

当 发送 class 消息 时不管是 self 还是 super 其消息主体依然是 self ,也就是说 self 和 super 指向的 是同一个对象。只是 查找方法的位置 区别，一个从本类，一个从本类的超类。 
一般情况下 class 方法 只有在 根类 NSObject 中定义，极少情况有子类重写 class 方法， 
所以 [slef class] 和 [super class] 都是在 根类中 找方法实现， 消息接收主体 又都是 a 
如果重写可能会不一样。 
自然都打印出 Son

在来一个例子：

#import 

@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];//间接调用父类方法，

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33

打印当然都是 ：

Engine 
Engine

方法体中 self 始终指代 方法的接收者 及对象 engine。， 
换成 NSLog(@”=EngineSuper=======%@”,[super class]); 结果也是一样的。

super 就是个障眼法 发，编译器符号， 它可以替换成 [slef class],只不过 方法是从 self 的超类开始 寻找。

参考：

1.   

Objective-C语言--self和super关键字解析

http://blog.csdn.net/addychen/article/details/46893359

2. 

【Objective-C】08-self关键字

http://www.cnblogs.com/mjios/archive/2013/04/20/3031758.html