IOS开发学习笔记（十二）——ObjectC中的复杂类型

简单类型就不说了，基本上每个语言都差不多。本次我们仅讨论非简单数据类型。

类的继承

头文件

#import <Foundation/Foundation.h>

// MyDummy类从NSObject继承而来
@interface MyDummy : NSObject

/*
* '-'标识是实例方法而不是静态方法；
* 返回值用'()'括号括起来，后面跟上方法名；
* 冒号后跟上第一个参数类型(继续使用括号括起来)和参数
* 空格后跟第二个参数+冒号+类型+参数名
* 最后用分号结束
*/
- (void)foo:(NSString *)username password:(NSString *)passwd;

@end

实现文件

#import "MyDummy.h"

@implementation MyDummy

/*
* 根据声明生成
*/
-(void)foo:(NSString *)username password:(NSString *)passwd {
NSLog(@"Your name is %@, your password is %@", username, passwd);
}

@end

测试文件

#import <Foundation/Foundation.h>
#import "MyDummy.h"

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

@autoreleasepool {
NSString *username = [[NSString alloc] initWithFormat:@"Sam"];
NSString *password = [[NSString alloc] initWithFormat:@"sssssssssss"];

MyDummy *dummy = [[MyDummy alloc] init];

[dummy foo:username password:password];

}
return 0;
}

Category

category和继承有部分类似，不过相对来说比继承关系要简单，我们看一下：

头文件

#import "MyDummy.h"

// 注意声明方式与继承不同
@interface MyDummy (MyDummy_SayHello)
// 方法的声明方式完全相同
-(void) sayHello:(NSString *)username password:(NSString *)password;

@end

实现文件

#import "MyDummy+MyDummy_SayHello.h"

@implementation MyDummy (MyDummy_SayHello)

-(void) sayHello:(NSString *)username password:(NSString *)password {
// 直接调用现有Dummy方法
return [self foo:username password:password];
}

@end

测试文件

#import <Foundation/Foundation.h>
#import "MyDummy.h"
#import "MyDummy+MyDummy_SayHello.h"

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

@autoreleasepool {
NSString *username = [[NSString alloc] initWithFormat:@"Sam"];
NSString *password = [[NSString alloc] initWithFormat:@"sssssssssss"];
// 声明一个Dummy类的对象
MyDummy *dummy = [[MyDummy alloc] init];
// 对象的方法被扩展了
[dummy sayHello:username password:password];

}
return 0;
}

Protocol--协议

Protocol在java中对应的是接口。我们在ObjectC中这样使用：

定义protocol

#import <Foundation/Foundation.h>

@protocol IComparable <NSObject>

-(int) compare:(NSObject *)other;

@end

实现类的头文件

#import <Foundation/Foundation.h>
#import "IComparable.h"

@interface MyNumber : NSObject <IComparable>

@property int num;

-(int) compare:(NSObject *)other;

@end

实现类的实现文件

#import "MyNumber.h"
#import "IComparable.h"

@implementation MyNumber

@synthesize num;

-(int) compare:(NSObject *)other {
MyNumber *number = (MyNumber *) other;

return [self num] - [number num];
}

@end

测试类

#import <Foundation/Foundation.h>
#import "MyDummy.h"
#import "MyDummy+MyDummy_SayHello.h"
#import "MyNumber.h"

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

@autoreleasepool {

MyNumber *num1 = [[MyNumber alloc] init];
MyNumber *num2 = [[MyNumber alloc] init];

[num1 setNum:10];
[num2 setNum:100];

NSLog(@"the number is %d", [num1 compare: num2]);
}
return 0;
}

id(动态类型)

ID类型很常见，例如alloc方法，init方法。ID类型很像以前Object Pascal中的variable类型，可以代表任意一种类型；或者你可以将他看成Java中的Object类型。但是一个很明显的差别在于：Java是强类型语言，所以所有的类型转换、方法调用都会检查类型；但ObjectC中，只要你将一个变量定义为id，那么编译器不会再做类型检查工作，甚至连warning都不抛出。

我们看看代码：

父类

#import <Foundation/Foundation.h>

@interface ParentClass : NSObject

@end

#import "ParentClass.h"

@implementation ParentClass

@end

第一个子类

#import "ParentClass.h"

@interface Child1 : ParentClass

-(void) foo1;

@end

#import "Child1.h"

@implementation Child1

-(void) foo1 {
NSLog(@"foo1 invoked.");
}

@end

第二个子类

#import "ParentClass.h"

@interface Child2 : ParentClass

-(void) foo2;

@end

#import "Child2.h"

@implementation Child2

-(void) foo2{
NSLog(@"foo2 invoked.");
}

@end

测试代码

#import <Foundation/Foundation.h>
#import "ParentClass.h"
#import "Child1.h"
#import "Child2.h"

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

@autoreleasepool {

NSLog(@"child1");
Child1 *child1 = [[Child1 alloc] init];
[child1 foo1];
// 下面这一句无法编译
// [child1 foo2];

NSLog(@"child2");
id child2 = [[Child2 alloc] init];
// 下面这一句会爆出异常
// [child2 foo1];
[child2 foo2];

NSLog(@"child3");
id child3 = [[Child2 alloc] init];
// 下面这一段先判断类型，之后调用，安全
if ([child3 isKindOfClass:[Child1 class]]) {
// 下面这句不会调用
[child3 foo1];
}
// 下面这一段先判断是否包含指定方法，之后调用，同样安全
if ([child3 respondsToSelector:@selector(foo2)]) {
// 下面这句会调用
[child3 foo2];
}
}
return 0;
}