Objective-C路成魔【11-多态性、动态类型和动态绑定】

#import <Foundation/Foundation.h>


@interface Vector : NSObject {
	double vec1;
	double vec2;
}

@property double vec1,vec2;
-(void)print;
-(void)setVec1:(double)v1 andVec2:(double) v2;
-(Vector *)add:(Vector *)v;

@end

#import "Vector.h"


@implementation Vector
@synthesize vec1,vec2;
-(void) setVec1:(double) v1 andVec2:(double)v2 {
	vec1 = v1;
	vec2 = v2;
}
-(Vector *)add:(Vector *)v {
	Vector *result = [[Vector alloc] init];
	[result setVec1:vec1 + [v vec1] andVec2: vec2 + [v vec2]];
	return result;
}

-(void)print {
	NSLog(@"%g,  %g",vec1,vec2);
}

@end

#import <Foundation/Foundation.h>


@interface Scalar : NSObject {
	double scal;
}
@property double scal;
-(void)print;
-(void)setScal:(double)sval;
-(Scalar *)add:(Scalar *)s;

@end

#import "Scalar.h"


@implementation Scalar

@synthesize scal;

-(void)print {
	NSLog(@"%g", scal);
}

-(void)setScal:(double)sval {
	scal = sval;
}

-(Scalar *)add:(Scalar *)s {
	Scalar *result  = [[Scalar alloc] init];
	[result setScal:scal + [s scal]];
	return result;
}

#import <Foundation/Foundation.h>

#import "Vector.h"
#import "Scalar.h"

int main (int argc, const char * argv[]) {
	
	Scalar *scA =[[Scalar alloc] init];
	Scalar *scB =[[Scalar alloc] init];

	Vector *vecA =[[Vector alloc] init];	
	Vector *vecB =[[Vector alloc] init];
	
	id scAandB;
	id vecAandB;

	[scA setScal: 10.5];
	[scB setScal: 13.1];
	[vecA setVec1: 3.2 andVec2: 4.7];
	[vecB setVec1: 32.2 andVec2: 47.7];

	[vecA print];
	NSLog(@" + ");
	[vecB print];
	NSLog(@" = ");
	vecAandB = [vecA add: vecB];
	[vecAandB print];
	[scA print];
	NSLog(@" + ");
	[scB print];
	NSLog(@" = ");
	scAandB = [scA add: scB];
	[scAandB print];
	
	[scA release];
	[scB release];
	[scAandB release];
	[vecA release];
	[vecB release];
	[vecAandB release];
    
	return 	0;
}

为什么要使用静态类型：

1）将一个变量定义为特定类的对象时，使用的是静态类型。

“静态”指的是对存储在变量中对象的类型进行显示声明。

这样存储在这样的形态中的对象的类是提前定义的，也就是静态的。

使用静态类型时，编译尽可能确保变量的使用方法在程序中始终保持一致。

编译器可以通过检查来确定应用于对象的方法是由该类定义的还是由该类继承的，否则它将显示警告信息。

也就是说“静态类型” 在编译阶段检查错误。 而不是在运行阶段。 

2）使用静态类型的还有一个原因是程序可读性好。。

动态类型的參数和返回类型：

怎样使用动态类型来调用一个方法，须要注意例如以下规则：

假设在多个类中实现名称同样的方法，那么每一个方法都必须符合各个參数的类型和返回值类型。

这样编译器才干为消息表达式生成正确的代码。

编译器会对它所遇到的每一个类声明运行一致性检查。

当一个方法选取对象作为它的參数，而还有一个方法选取浮点数作为參数时，

或者一个方法以对象作为返回值。而还有一个以整型数作为返回值。

编译器可能生成不对的代码来向方法传递參数或处理返回值。

处理动态类型的方法：

-(BOOL) isKindOf:class-object（推断对象是否是class-object或其子类的成员）  
-(BOOL) isMenberOfClass: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 withObject:object2（应用selector指定的方法，传递參数object1和object2

能够对一个方法名应用@selector指令。

比如：@selector （alloc）为名为alloc的方法生成一个SEL类型的值，该方法是从NSObject类继承的。

记住。測试包括继承的方法，并非仅仅測试直接定义在类中的方法。

performSelector：方法和它的变体同意你向对象发送消息，这个消息能够是存储在变量中的selector。

在iOS中，respondsToSelector：方法广泛用于实现托付（delegation）的概念。

为了让系统可以检查你确实实现了特定的方法，

使用respondsToSelector：推断能否够将事件的处理托付给你的方法。

假设你没有实现这种方法，它会自己处理该事件，按定义的默认行为来运行。

使用@try处理异常

@try：假设块中的某一语句抛出异常。运行不会终止。而是马上跳到@catch块继续运行

@catch：处理异常，可行的运行顺序是记录出错信息。清除和终止运行。

@finally：使用@finally块包括是否运行抛出异常的@try块中的语句代码；

@throw：同意你抛出自己的异常。

这些概念和java的或者其他语言差点儿相同。

一般来说，须要考虑更好的编程实践，

应该在发生错误前做系统的全面的覆盖性測试，而不是在发生错误后捕获异常。

抛出异常会使用大量的系统资源，Apple反对非必要的使用异时常。