C：self 和super的区别

Objective C: Difference between self and super

我刚接触到目标C。我正在尝试一些示例程序。我无法理解目标C中的self和super方法是如何工作的。在cashtransaction下面的pgm中，调用m[超级跟踪支出：金额]，在creditcardttransaction中调用m[自我跟踪支出：金额]，我找不到self和super之间的区别。super用于调用基类overriden method.and self是为了调用子类overrided method。这是我的理解。如果我错了，请纠正我。谢谢在advace中。

主m

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#import <Foundation/Foundation.h>
#import"BudgetObject.h"
#import"Transaction.h"
#import"CashTransaction.h"
#import"CreditCardTransaction.h"

int main (int argc, const char * argv[]) {

//!---Creating An Object And Allocating It With Values---
Budget* budget = [Budget new];
[budget createBudget:1000.00 withExchangeRate:1.2500];

//!---Declaring And Adding Elements To An Array---
NSMutableArray* transactions = [[NSMutableArray alloc] initWithCapacity:10];
Transaction* aTransaction;
aTransaction = [Transaction new];
[transactions addObject:aTransaction];

//!---Calculating The No Of Elements In An Array---
int k;
k=[transactions count];
NSLog(@"The count value is:%d",k);

//!---Selecting According To The Type Of Transaction---
for(Transaction *iTransaction in transactions){
switch ([aTransaction returnType]) {
case cash:
[budget spendDollars:[iTransaction returnAmount]];
break;
case credit:
[budget changeForeignCurrency:[iTransaction returnAmount]];
break;
default:
break;
}
}

Budget* europeBudget = [Budget new];
[europeBudget createBudget:1000.00 withExchangeRate:1.2500];

Budget* englandBudget = [Budget new];
[englandBudget createBudget:2000.00 withExchangeRate:1.5000];

NSMutableArray* transactions = [[NSMutableArray alloc] initWithCapacity:10];
Transaction* aTransaction;
for(int n=1;n<2;n++){
aTransaction = [CashTransaction new];
[aTransaction createTransaction:n*100 forBudget:europeBudget];
[transactions addObject:aTransaction];

aTransaction = [CashTransaction new];
[aTransaction createTransaction:n*100 forBudget:englandBudget];
[transactions addObject:aTransaction];
}
int n=1;
while (n<4) {
aTransaction = [CreditCardTransaction new];
[aTransaction createTransaction:n*100 forBudget:europeBudget];
[transactions addObject:aTransaction];

aTransaction = [CreditCardTransaction new];
[aTransaction createTransaction:n*100 forBudget:englandBudget];
[transactions addObject:aTransaction];

n++;
}
for(Transaction* aTransaction in transactions){
[aTransaction spend];
}
return 0;
}

预算对象

1
2
3
4
5
6
7
8
9
10

#import <Cocoa/Cocoa.h>
@interface Budget : NSObject {
float exchangeRate;
double budget;
double exchangeTransaction;
}
- (void) createBudget: (double) aBudget withExchangeRate: (float) anExchangeRate;
- (void) spendDollars: (double) dollars;
- (void) changeForeignCurrency: (double) foreignCurrency;
@end

预算对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#import"BudgetObject.h"
@implementation Budget
- (void) createBudget: (double) aBudget withExchangeRate: (float) anExchangeRate;
{
budget = aBudget;
exchangeRate = anExchangeRate;
}
- (void) spendDollars: (double) dollars
{
budget = budget - dollars;
NSLog(@"Converting %0.2f into U.S Foreign Currency leaves $%0.2f",dollars,budget);
}
- (void) changeForeignCurrency: (double) foreignCurrency
{
exchangeTransaction = foreignCurrency * exchangeRate;
budget = budget - exchangeTransaction;
NSLog(@"Charging %0.2f in Foreign Currency leaves $%0.2f",foreignCurrency,budget);
}
@end

事务处理

1
2
3
4
5
6
7
8
9
10
11

#import <Cocoa/Cocoa.h>
#import"BudgetObject.h"
@class Budget;
@interface Transaction : NSObject {
Budget* budget;
double amount;
}
- (void) createTransaction: (double) theAmount forBudget: (Budget*) aBudget;
- (void) trackSpending: (double) theAmount;
- (void) spend;
@end

事务处理

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

#import"Transaction.h"
#import"BudgetObject.h"
@implementation Transaction
- (void) createTransaction: (double) theAmount forBudget: (Budget*) anBudget {
budget = anBudget;
amount = theAmount;
}
- (void) spend {

}
-(void) trackSpending: (double) theAmount {
NSLog(@"You are about to spend another %0.2f",theAmount);
}
@end

现金交易.h

1
2
3
4
5
6

#import <Cocoa/Cocoa.h>
#import"Transaction.h"
@interface CashTransaction : Transaction {

}
@end

现金交易.m

1
2
3
4
5
6
7
8

#import"CashTransaction.h"
#import"BudgetObject.h"
@implementation CashTransaction
- (void) spend{
[super trackSpending:amount];
[budget spendDollars:amount];
}
@end

信用卡交易.h

1
2
3
4
5
6

#import <Cocoa/Cocoa.h>
#import"Transaction.h"
@interface CreditCardTransaction : Transaction {

}
@end

信用卡交易.m

1
2
3
4
5
6
7
8

#import"CreditCardTransaction.h"
#import"BudgetObject.h"
@implementation CreditCardTransaction
- (void) spend {
[self trackSpending:amount];
[budget changeForeignCurrency:amount];
}
@end

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2011-04-15 11:24:46.112 Bud Obj1[1041:a0f] You are about to spend another 100.00
2011-04-15 11:24:46.114 Bud Obj1[1041:a0f] Converting 100.00 into U.S Foreign Currency leaves $900.00
2011-04-15 11:24:46.115 Bud Obj1[1041:a0f] You are about to spend another 100.00
2011-04-15 11:24:46.115 Bud Obj1[1041:a0f] Converting 100.00 into U.S Foreign Currency leaves $1900.00
2011-04-15 11:24:46.116 Bud Obj1[1041:a0f] You are about to spend another 100.00
2011-04-15 11:24:46.119 Bud Obj1[1041:a0f] Charging 100.00 in Foreign Currency leaves $775.00
2011-04-15 11:24:46.120 Bud Obj1[1041:a0f] You are about to spend another 100.00
2011-04-15 11:24:46.120 Bud Obj1[1041:a0f] Charging 100.00 in Foreign Currency leaves $1750.00
2011-04-15 11:24:46.121 Bud Obj1[1041:a0f] You are about to spend another 200.00
2011-04-15 11:24:46.121 Bud Obj1[1041:a0f] Charging 200.00 in Foreign Currency leaves $525.00
2011-04-15 11:24:46.122 Bud Obj1[1041:a0f] You are about to spend another 200.00
2011-04-15 11:24:46.122 Bud Obj1[1041:a0f] Charging 200.00 in Foreign Currency leaves $1450.00
2011-04-15 11:24:46.123 Bud Obj1[1041:a0f] You are about to spend another 300.00
2011-04-15 11:24:46.123 Bud Obj1[1041:a0f] Charging 300.00 in Foreign Currency leaves $150.00
2011-04-15 11:24:46.124 Bud Obj1[1041:a0f] You are about to spend another 300.00
2011-04-15 11:24:46.125 Bud Obj1[1041:a0f] Charging 300.00 in Foreign Currency leaves $1000.00

self和super的工作方式截然不同：self表示运行时的调用对象，super表示方法定义所在的类的超类。在这两种情况下，它们都指定了方法的搜索应该从哪里开始，在self的情况下，起始点是动态确定的，在super的情况下，在编译时就知道了。

下面是一个组合示例：

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

@interface Grandparent : NSObject

- (void) One;

@end

@implementation Grandparent

- (void) One { NSLog(@"Grandparent One
"); }

@end

@interface Parent : Grandparent

- (void) One;
- (void) Two;

@end

@implementation Parent

- (void) One { NSLog(@"Parent One
"); }

- (void) Two
{
[self One]; // will call One based on the calling object
[super One]; // will call One based on the defining object - Parent in this case so will Grandparent's One
}

@end

@interface Child : Parent

- (void) One;

@end

@implementation Child

- (void) One { NSLog(@"Child One
"); }

@end

@implementation FamilyAppDelegate

@synthesize window;

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
{
Child *c = [Child new];
[c Two]; // will call the Two inherited from Parent

Parent *p = [Parent new];
[p Two]; // will call Parent's Two
}

@end

所以我们有三个类：Grandparent、Parent和Child；每个类都有一个方法One。类Parent has a methodtwowhich callsoneonselfeandsuper `。运行此程序会产生：

1
2
3
4

2011-04-15 22:49:05.006 Family[1993:a0f] Child One
2011-04-15 22:49:05.009 Family[1993:a0f] Grandparent One
2011-04-15 22:49:05.009 Family[1993:a0f] Parent One
2011-04-15 22:49:05.010 Family[1993:a0f] Grandparent One

对于Child情况，调用调用Child从其Parent继承的方法Two，因此我们有继承权。

现在，当Two执行时，它首先调用[self One]，self是Child的一个实例，它有一个One，所以Child的One被执行-这是基于继承的多态性；在定义Parent的Two时，Child的未来存在是未知的，但在执行时我调用[self One]可以调用Child的方法。

Two中的下一个调用是[super One]。现在我们知道，在定义时，这是指Grandparent的One。

一般来说，super并不引用超类中的方法(在本例中是这样)，但对于方法，类型为超类的对象将调用，例如，它可以属于Greatgrandparent。然而，无论调用什么方法，都可以在编译时确定，因为任何类的祖先都是已知的。

调用[self *method*]和[super *method*]甚至可以调用相同的方法，在前一种情况下动态找到，在后一种情况下静态知道。

希望您现在可以将继承，self和super应用到您的示例中。