多态能够使来自不同类的对象定义相同的方法。动态类型能使程序直到执行时才确定对象所属的类。动态绑定则能使程序直到执行时才确定实际要调用的对象的方法。

示例一：多态

Fraction.h

#import <Foundation/Foundation.h>

@interface Fraction : NSObject

//@property指令让编译器自动为numerator、denominator生成getter、setter方法
@property int numerator, denominator;

-(void) print;
+(int) printCallCount;
-(double) convertToNum;
-(void) setTo: (int) n over: (int) d;
-(void) set: (int) n : (int) d;
-(Fraction *) add: (Fraction *) f;
-(void) reduce;

@end

Fraction.m

#import "Fraction.h"

@implementation Fraction

@synthesize numerator, denominator;

// 统计所有对象调用print方法的次数,默认值为0
static int printCount;

// 静太方法
+(int) printCallCount
{
    return printCount;
}

-(void) print
{
    printCount++;
    //统计本实例对象调用print方法的次数,局部静态变量只会在方法第一次调用时初始化一次
    static int printCountIns = 0;
    printCountIns++;
    
    NSLog(@"%i/%i", numerator, denominator);
}

-(double) convertToNum
{
    if (denominator != 0)
        return (double) numerator / denominator;
    else
        return NAN;
}

// 多个参数的方法
-(void) setTo: (int) n over: (int) d
{
    numerator = n;
    denominator = d;
}

// 省略参数名的多个参数方法
// 注意，第一个参数名不能省
// 省略参数名不是一种好的编程风格，因为它使程序很难读懂并且很不直观,特别是参数很重要时。
-(void) set: (int) n : (int) d
{
    numerator = n;
    denominator = d;
}

// 分数相加
-(Fraction *) add: (Fraction *) f
{
    // 添加两个分数
    // a/b+c/d=((a*d)+(b*c))/(b*d)
    
    // 创建一个新对象来存储结果
    Fraction *result = [[Fraction alloc] init];
    result.numerator = numerator * f.denominator + denominator * f.numerator;
    result.denominator = denominator * f.denominator;
    
    // self关键字相当于C#的this
    // [self reduce];
    
    [result reduce];
    
    return result;
}

// 约分
-(void) reduce
{
    int u = numerator;
    int v = denominator;
    int temp;
    
    while (v != 0) {
        temp = u % v;
        u = v;
        v = temp;
    }
    
    numerator /= u;
    denominator /= u;
}

@end

Complex.h

#import <Foundation/Foundation.h>

@interface Complex : NSObject

@property double real, imaginary;
-(void) print;
-(void) setReal: (double) a andImaginary: (double) b;
-(Complex *) add: (Complex *) f;

@end

Complex.m

#import "Complex.h"

@implementation Complex

@synthesize real, imaginary;

-(void) print
{
    NSLog(@" %g + %gi ", real, imaginary);
}

-(void) setReal: (double) a andImaginary: (double) b
{
    real = a;
    imaginary = b;
}

-(Complex *) add: (Complex *) f
{
    Complex *result = [[Complex alloc] init];
    
    result.real = real + f.real;
    result.imaginary = imaginary + f.imaginary;
    
    return result;
}

@end

main.m

#import <Foundation/Foundation.h>
#import "Fraction.h"
#import "Complex.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Fraction *f1 = [[Fraction alloc] init];
        Fraction *f2 = [[Fraction alloc] init];
        Fraction *fracResult;
        Complex *c1 = [[Complex alloc] init];
        Complex *c2 = [[Complex alloc] init];
        Complex *compResult;
        
        [f1 setTo: 1 over: 10];
        [f2 setTo: 2 over: 15];
        
        [c1 setReal: 18.0 andImaginary: 2.5];
        [c2 setReal: -5.0 andImaginary: 3.2];
        
        // 将两个复数加相并显示
        [c1 print]; NSLog(@"        +"); [c2 print];
        NSLog(@"----------");
        compResult = [c1 add: c2];
        [compResult print];
        NSLog(@"\n");
        
        // 将两个分数相加并显示
        [f1 print]; NSLog(@"  +"); [f2 print];
        NSLog(@"----");
        fracResult = [f1 add: f2];
        [fracResult print];
        
        // Fraction和Complex都有add和print方法
        // 使不同的类共享相同方法名称的能力称为多态
    }
    return 0;
}

运行测试

示例二：动态绑定和id类型

main.m

#import <Foundation/Foundation.h>
#import "Fraction.h"
#import "Complex.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        id dataValue;
        
        Fraction *f1 = [[Fraction alloc] init];
        Complex *c1 = [[Complex alloc] init];

        [f1 setTo: 2 over: 5];
        [c1 setReal: 10.0 andImaginary: 2.5];
        
        // 动态绑定
        // 存储在id变量中的对象类型在编译时无法确定,一些测试推迟到运行时进行
        // id变量不能使用点运算符
        
        dataValue = f1;
        [dataValue print];
        
        dataValue = c1;
        [dataValue print];
    }
    return 0;
}

运行测试

处理动态类型的方法
方法	问题或行为
-(BOOL) isKindOfClass: class-object	对象是不是class-object或其子类的成员
-(BOOL) isMemberOfclass: class-object	对象是不是class-object的成员
-(BOOL) respondsToSelector: Selector	对象是否能够响应selector所指定的方法
+(BOOL) instancesRespondToSelector: Selector	指定的类实例是否能响应selector
+(BOOL) isSubclassOfClass: class-object	对象是否是指定类的子类
-(id) performSelector: selector	应用selector指定的方法
-(id) performSelector: selector withObject: object	应用selector指定的方法，传递参数object
-(id) performSelector: selector withObject: object1 withObject2 object2	应用selector指定的方法，传递参数object1和object2

示例三
用到了之前文章中的Rectangle类、Square类
参见 http://www.devacg.com/?post=924

main.m

#import <Foundation/Foundation.h>
#import "Square.h"
#import "Rectangle.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Square *mySquare = [[Square alloc] init];
        
        // isMemberOf: 测试类中的直接成员关系
        
        if ( [mySquare isMemberOfClass: [Square class]] == YES )
            NSLog(@"mySquare is a member of Square class");
        
        if ( [mySquare isMemberOfClass: [Rectangle class]] == YES )
            NSLog(@"mySquare is a member of Rectangle class");
        
        if ( [mySquare isMemberOfClass: [NSObject class]] == YES )
            NSLog(@"mySquare is a member of NSObject class");
        
        // isKindOf: 检测继承层次中的关系
        
        if ( [mySquare isKindOfClass: [Square class]] == YES )
            NSLog(@"mySquare is a kind of Square");
        
        if ( [mySquare isKindOfClass: [Rectangle class]] == YES )
            NSLog(@"mySquare is a kind of Rectangle");
        
        if ( [mySquare isKindOfClass: [NSObject class]] == YES )
            NSLog(@"mySquare is a kind of NSObject");
        
        // respondsTo:
        
        if ( [mySquare respondsToSelector: @selector (setSide:)] == YES )
            NSLog(@"mySquare responds to setSide: method");
        
        if ( [mySquare respondsToSelector: @selector (setWidth:andHeight:)] == YES )
            NSLog(@"mySquare responds to setWidth:andHeight: method");
        
        if ( [Square respondsToSelector: @selector (alloc)] == YES )
            NSLog(@"Square responds to alloc method");
        
        // instancesRespondTo:
        
        if ( [Rectangle instancesRespondToSelector: @selector (setSide:)] == YES )
            NSLog(@"Instances of Rectangle respond to setSide: method");
        
        if ( [Square instancesRespondToSelector: @selector (setSide:)] == YES )
            NSLog(@"Instances of Square respond to setSide: method");
        
        if ( [Square isSubclassOfClass: [Rectangle class]] == YES )
            NSLog(@"Square is a subclass of a rectangle");
    }
    return 0;
}

运行测试