多态是一个典型的面向对象概念。Objective-C中的多态可以使得来自不同类的对象定义同名方法。
我们来看下面的示例，分数类Fraction我们已经多次涉及到了，我们来回顾一下我们分数类的定义：
#import@interface Fraction : NSObject @property int numerator,denominator; -(void) print; -(double) convertToNum; -(void) setTo:(int) n over: (int) d; -(Fraction *)add:(Fraction *)f; -(void) reduce; @end
方法convertToNum是将分数转化为小数形式，setTo...over方法是设置分数的，reduce是约分方法，这是对于分数处理所特有的方法和命名。那么print和add方法则是两个比较普通的方法。那么我们定义其它类也可以包含print和add方法来实现其它效果。
比如数学概念中有复数的概念，复数由实部和虚部构成，那么我们创建复数类Complex的定义，代码可以是这样的：
#import@interface Complex : NSObject @property double real,imaginary; -(void) print; -(void) setReal:(double)r andImaginary:(double)i; -(Complex *) add:(Complex *) c; @end
复数类的定义比较简单，仅仅是为了说明问题，定义了实部和虚部的两个double类型变量， print和add方法的命名是和分数类Fraction一致的，只是设置复数的方法命名和setTo...over不同，那么它的实现如下：
#import "Complex.h"
@implementation Complex
@synthesize real,imaginary;
-(void) print
{
NSLog(@"%g + %gi",real,imaginary);
}
-(void) setReal:(double)r andImaginary:(double)i
{
real=r;
imaginary=i;
}
-(Complex *) add:(Complex *)c
{
Complex *result=[Complex new];
result.real=real+c.real;
result.imaginary=imaginary+c.imaginary;
return result;
}
@end
对定义的三个方法进行实现，代码很简单，意思就不过多解释了，那么来看主函数：
#import "Fraction.h"
#import "Complex.h"
int main(int argc, const char * argv[])
{
@autoreleasepool {
Fraction *fractionA = [Fraction new];
Fraction *fractionB = [Fraction new];
Fraction *resultFraction;
[fractionA setTo:1 over:3];
[fractionB setTo:2 over:5];
[fractionA print];NSLog(@" +");[fractionB print];
NSLog(@"---");
resultFraction=[fractionA add:fractionB];
[resultFraction print];
Complex *complexA=[Complex new];
Complex *complexB=[Complex new];
Complex *resultComplex;
[complexA setReal:10.0 andImaginary:2.3];
[complexB setReal:-5.0 andImaginary:3.6];
[complexA print];NSLog(@" +");[complexB print];
NSLog(@"---------");
resultComplex=[complexA add:complexB];
[resultComplex print];
}
return 0;
}
我们分别定义了两个分数和两个复数，分别对其使用add方法进行相加，然后使用print方法进行打印。编译运行这个程序，我们得到如下的结果：
那么可以看到，我们分别得到了正确的结果。在Objective-C中不同的类使用相同的方法名的能力称为多态。那么我们在开发一组类时，它们可以使用相同的方法名而每个类又有不同的实现代码。那么多态还允许你创建心类时，这些新类也使用相同的方法名。
我们继续来深入说明。在Objective-C中有一种数据类型比较特殊，就是id类型。id表示一种通用的对象类型，也就是说id可以用来存储任何类的对象。那么我们使用这种方式来存储不同类型的对象时，在程序运行期间，这种数据类型的优势就体现出来了，我们修改上面的主函数，使用id类型来看一下：
#import "Fraction.h"
#import "Complex.h"
int main(int argc, const char * argv[])
{
@autoreleasepool {
id result;
Fraction *fractionA = [Fraction new];
Fraction *fractionB = [Fraction new];
[fractionA setTo:1 over:3];
[fractionB setTo:2 over:5];
[fractionA print];NSLog(@" +");[fractionB print];
NSLog(@"---");
result=[fractionA add:fractionB];
[result print];
Complex *complexA=[Complex new];
Complex *complexB=[Complex new];
[complexA setReal:10.0 andImaginary:2.3];
[complexB setReal:-5.0 andImaginary:3.6];
[complexA print];NSLog(@" +");[complexB print];
NSLog(@"---------");
result=[complexA add:complexB];
[result print];
}
return 0;
}
和之前的程序相比，这里我们定义了id类型的result变量，并且删除了分数类和复数类各自的result对象，统一使用id类型的变量作为替代，那么运行程序，我们先来看一下结果：
可以看到，程序依然正确运行，我们得到了想要的结果。这里我们将result定义成id类型，那么它就可以表示任何类型的对象，请特别注意，这个声明不是指针类型，不加星号。那么在做分数运算时，result首先被赋值为Fraction类型，这是Objective-C程序运行时的动态类型和动态绑定机制，这种动态机制就是在运行时先判断对象所属的类，然后调用对应的方法，而在编译时是不检查的。依照这个理论，那么在执行复数类的print时，result对象已经赋值为了复数类型的结果，那么自然打印复数。
想想我们之前的矩形和正方形的例子，如果加入了draw方法，那么对于矩形和正方形的实现肯定是不同的。而若在程序中我们可能还会有圆形，三角形等图案，那么若定义了id类型的shape变量，它就可以表示任何图形了，在运行时动态确定结果，动态选择要执行的所属类的draw方法就可以得到不同的图案了，这就是动态类型和动态绑定的实现。
看下面的代码段：
Fraction *f = [Fraction new]; [f setReal:10.0 addImaginary:3.6];
这里我们定义了分数类型的对象f，对f调用了复数类的setReal...addImaginary方法，这显然是无法通过编译的，因为编译器知道f的类型，Fraction类中没有setReal...addImaginary方法的定义或者继承这个方法，那么在编译阶段就会报出错误。这很好理解，接着来看：
id data=[Fraction new]; [data setReal:10.0 addImaginary:3.6];
这样的代码在编译时不会发生错误，因为data可以表示任意类型，编译器在编译时不会检查对象的具体类型。而当程序运行时，显然会出现问题，因为data是Fraction类型的，而Fraction类型没有定义/继承setReal...addImaginary方法。那么就会出错，这就是运行时报错。
以上两种情况就说明了编译时检查和运行时检查机制。也可以看出如果滥用id类型会埋下的潜在隐患。因为id类型可以看做是动态类型，即编译器不会检查对象的类型，而是在运行时动态确定的，如果对象和要执行的方法不匹配，就会出错。而将变量定义为特定类型的对象时，就是静态类型，静态类型是会接受编译器检查的。很显然静态类型可以在编译阶段就指出错误而且提高程序的可读性。
同时，使用动态类型调用方法时，如果在多个类中定义有同名方法，那么这个方法的各个参数类型和返回值类型要一致。
引入动态类型后，问题随之而来。比如说在运行时如何判断一个对象是某种类型，一个对象是否支持某方法，一个对象是否是某类或是其子类的成员。幸运的是，NSObject类为我们提供了一些方法用于处理这类问题，要使用这些方法，我们需要一些铺垫，首先介绍class方法，看下面的示例代码：
#import "Square.h"
int main(int argc, const char * argv[])
{
@autoreleasepool {
Rectangle *rect=[Rectangle new];
Class cls=[rect class];
NSLog(@"%@",cls);
NSLog(@"%@",[Square class]);
}
return 0;
}
首先我们创建了一个Rectangle对象rect，之后对rect调用class方法返回一个Class类型的对象，然后打印这个cls对象的内容。而下面我们对Square类直接调用class方法，也能返回Class对象，那么编译运行，我们得到如下结果：
我们可以看到通过class方法我们可以获取当前对象的类型，使用类名来调用通常也是为了返回这个类型的对象，他们都是Class类型的对象。那么我们知道class方法的用处后就可以用于判断了，比如下面的代码：
#import "Square.h"
int main(int argc, const char * argv[])
{
@autoreleasepool {
Rectangle *rect=[Rectangle new];
Square *square=[Square new];
Rectangle *rectangle=[Rectangle new];
if([rect class]==[rectangle class]){
NSLog(@"rect & rectangle is the same class");
}
if([square class]==[rect class]){
NSLog(@"square & rect is the same class");
}
}
return 0;
}
那么我们很容易就能与基础该程序的效果，请看下图所示：
下面介绍@selector指令，该指令用于一个方法名，比如@selector (alloc)，它的返回值是SEL类型，这个指令所获取的SEL类型结果也是用于动态类型的一些方法的，这里我们仅仅有个感性认识即可，那么看下面的代码：
#import "Square.h"
int main(int argc, const char * argv[])
{
@autoreleasepool {
SEL sel=@selector(setSide);
NSLog(@"SEL=%@",NSStringFromSelector(sel));
}
return 0;
}
这里我们需要将SEL结果转换成NSString类型，那么编译运行，我们会得到如下结果：
那么在后面处理动态类型的方法中，我们会看到@selector指令的具体用途。参考下面的程序：
#import "Square.h"
int main(int argc, const char * argv[])
{
@autoreleasepool {
Square *square=[Square new];
NSLog(@"%@",[square isMemberOfClass:[Square class]]?@"YES":@"NO");
NSLog(@"%@",[square isMemberOfClass:[Rectangle class]]?@"YES":@"NO");
NSLog(@"%@",[square isMemberOfClass:[NSObject class]]?@"YES":@"NO");
NSLog(@"%@",[square isKindOfClass:[Square class]]?@"YES":@"NO");
NSLog(@"%@",[square isKindOfClass:[Rectangle class]]?@"YES":@"NO");
NSLog(@"%@",[square isKindOfClass:[NSObject class]]?@"YES":@"NO");
NSLog(@"%@",[square respondsToSelector:@selector(setSide:)]?@"YES":@"NO");
NSLog(@"%@",[square respondsToSelector:@selector(setWidth:andHeight:)]?@"YES":@"NO");
NSLog(@"%@",[Square respondsToSelector:@selector(alloc)]?@"YES":@"NO");
NSLog(@"%@",[Rectangle instanceRespondToSelector:@selector(setSide:)]?@"YES":@"NO");
NSLog(@"%@",[Square instanceRespondToSelector:@selector(setSide:)]?@"YES":@"NO");
NSLog(@"%@",[Square isSubclassOfClass:[Rectangle class]]?@"YES":@"NO");
}
return 0;
}
我们先来看运行结果：
我们逐行来解释一下这个程序，isMemberOfClass : class方法用于判断对象是不是class的成员，返回值为BOOL类型，那么这里我们使用三目运算符来获取BOOL表达式的结果，NSString也是id类型的一种，那么我们使用%@来表示。很显然square对象是Square类的一个成员，而不是Rectangle类和NSObject类的成员。
isKindOfClass: class方法用于判断对象是不是class类或其子类的成员。显然square对象是Square类的成员，是Rectangle类和NSObject类的子类成员。
respondsToSelector : selector方法用于判断对象是否可以响应@selector提供的方法，那么直接看上面的结果即可，不用多说了。instanceRespondToSelector : selector方法用于判断指定的实例能否响应@selector提供的方法，那么直接看结果就行了。
这些方法我们仅仅有个感性认识即可，等后续内容使用到了再做深入了解。
我们知道运用动态类型时在程序执行过程中可能会出现异常，那么如何来处理异常呢？Objective-C中引入@try块儿来处理异常，异常处理在@catch块中进行。我们来看下面的代码：
#import "Fraction.h"
#import "Complex.h"
int main(int argc, const char * argv[])
{
@autoreleasepool {
id result;
id fractionA = [Fraction new];
[fractionA setTo:1 over:3];
id complexA=[Complex new];
[complexA setReal:10.0 andImaginary:2.3];
@try {
result=[fractionA add:complexA];
}
@catch (NSException *exception) {
NSLog(@"Caught: %@%@",exception.name,exception.reason);
}
@finally {
NSLog(@"In finally");
}
}
return 0;
}
代码使用的是我们分数和复数的项目，那么为了引发异常，我们将分数类和复数类都使用id类型来表示，显然编译器不会报错，然后我们对两个不同的对象使用add方法，这显然是不可以的，那么将代码放入@try块中，在@catch块中进行异常处理，这里我们仅仅是打印一些异常信息。在@finally块中编写不论异常是否发生，都要执行的代码，那么编译运行后，我们得到如下结果：
之后我们修改代码，不会出现异常时是这样的情况：
#import "Fraction.h"
#import "Complex.h"
int main(int argc, const char * argv[])
{
@autoreleasepool {
id result;
id fractionA = [Fraction new];
[fractionA setTo:1 over:3];
id fractionB=[Fraction new];
[fractionB setTo:10 over:18];
@try {
result=[fractionA add:fractionB];
}
@catch (NSException *exception) {
NSLog(@"Caught: %@%@",exception.name,exception.reason);
}
@finally {
NSLog(@"In finally");
}
}
return 0;
}
此时代码不会出错了，那么编译运行就得到了如下结果：
可以看到@finally块中的语句无论异常是否发生，都会执行。所以它常用来进行连接的关闭等操作。如果想主动抛异常，还可以使用@throw指令来进行，这就是更高级内容了，暂时先不涉及。因为异常处理的开销很大，特别是移动设备对资源占用很敏感，所以非必要，请不要使用异常处理。
接下文
- 查看图片附件