代码改变世界

【转】Objective-C学习笔记十：继承二

2013-03-10 17:59  maying_07  阅读(140)  评论(0)  编辑  收藏  举报

原文地址：http://sarin.iteye.com/blog/1820469

   之前定义了矩形类Rectangle，那么我们如果要在桌面上生成这样一个矩形，就需要定位了。为了简便，我们定义桌面的左下角为直角坐标系（笛卡尔坐标系）的原点，横向向右为X轴正向，竖向向上为Y轴正向。那么我们只要确定了矩形的左下角坐标就可以得到矩形的位置了。此时我们就要引入坐标的概念，那么设计XYPoint类，代码如下： 

 

1 #import <Foundation/Foundation.h>
2 
3 @interface XYPoint : NSObject
4 
5 @property int x,y;
6 
7 -(void) setX:(int)xVal andY:(int) yVal;
8 @end

 

  XYPoint.h文件定义了坐标类XYPoint的接口信息，这里面我们使用整数作为坐标，暂时不考虑小数坐标点。那么提供一个方法来设置坐标点，其实现代码为： 

 

 1 #import "XYPoint.h"
 2 
 3 @implementation XYPoint
 4 
 5 @synthesize x,y;
 6 
 7 -(void) setX:(int)xVal andY:(int)yVal
 8 {
 9     x=xVal;
10     y=yVal;
11 }
12 
13 @end

 

  就是给属性x和y进行赋值，没有什么可多说的。因为我们要为矩形设置原点坐标（矩形左下角坐标），那么就需要对矩形类Rectangle进行修改，代码如下： 

 

 1 #import <Foundation/Foundation.h>
 2 
 3 @class XYPoint;
 4 
 5 @interface Rectangle : NSObject
 6 
 7 @property int width,height;
 8 
 9 -(int) area;
10 -(int) perimeter;
11 -(void) setWidth:(int) w andHeight:(int) h;
12 -(XYPoint *) origin;
13 -(void) setOrigin: (XYPoint *) point;
14 
15 @end

 

  这是类的接口文件，这里面我们使用了@class指令来指定XYPoint类，@class指令可以为我们指定要使用的类，而不用使用import语句，因为这里我们只需要引入XYPoint的定义而已。如果要引用类的实现部分，那么必须使用import语句，@class就不足以提供所需内容了。同时矩形类加入了两个方法，一个是设置原点origin坐标，一个是获取原点坐标，那么矩形类的实现就修改如下： 

 

 1 #import "Rectangle.h"
 2 
 3 @implementation Rectangle
 4 {
 5     XYPoint *origin;
 6 }
 7 @synthesize width, height;
 8 
 9 -(int) area
10 {
11     return width*height;
12 }
13 
14 -(int) perimeter
15 {
16     return (width+height)*2;
17 }
18 
19 -(void) setWidth:(int)w andHeight:(int)h
20 {
21     width=w;
22     height=h;
23 }
24 
25 -(XYPoint *) origin
26 {
27     return origin;
28 }
29 
30 -(void) setOrigin:(XYPoint *)point
31 {
32     origin=point;
33 }
34 @end

 

 

 

我们定义私有属性origin来表示坐标原点，提供了设置方法和获取方法，这就没什么可多说的了，最后来看看主函数，该如何使用它们： 

 

 1 #import "Rectangle.h"
 2 #import "XYPoint.h"
 3 
 4 int main(int argc, const char * argv[])
 5 {
 6 
 7     @autoreleasepool {
 8         Rectangle *rect=[Rectangle new];
 9         XYPoint *point=[XYPoint new];
10         
11         [point setX:10 andY:23];
12         
13         [rect setWidth:10 andHeight:23];
14         rect.origin=point;
15         
16         NSLog(@"Rectangle: width=%i, height=%i",rect.width,rect.height);
17         NSLog(@"Origin at (%i, %i)",rect.origin.x,rect.origin.y);
18         NSLog(@"Area = %i, Perimeter=%i",rect.area,rect.perimeter);
19         
20     }
21     return 0;
22 }

 

 主函数中需要引入两个头文件，因为使用到了它们。创建一个矩形变量和一个坐标变量，对它们赋值后，将坐标原点设置给矩形对象，那么此时矩形对象就拥有了坐标原点，之后我们打印出它们的值，编译运行后得到如下结果： 


 

    我们修改一下主函数，代码如下： 

 

 1 #import "Rectangle.h"
 2 #import "XYPoint.h"
 3 
 4 int main(int argc, const char * argv[])
 5 {
 6 
 7     @autoreleasepool {
 8         Rectangle *rect=[Rectangle new];
 9         XYPoint *point=[XYPoint new];
10         
11         [point setX:10 andY:23];
12         
13         [rect setWidth:32 andHeight:36];
14         rect.origin=point;
15 
16         NSLog(@"Origin at (%i, %i)",rect.origin.x,rect.origin.y);
17 
18         [point setX:23 andY:10];
19         NSLog(@"Origin at (%i, %i)",rect.origin.x,rect.origin.y);
20         
21     }
22     return 0;
23 }

 

这里只是对原点进行了二次赋值，那么编译运行后，我们得到如下结果： 

 


    为什么会得到这样的结果？我们并没有显式的再次设置矩形的原点，只是对原点对象重新赋值后，矩形的原点也发生了相应的变化。我们来仔细看一下代码，调用setOrigin方法时，point作为参数传递给该方法，这个值是指针对象，指向了XYPoint对象的内存地址。我们使用rect.origin=point将地址赋值给矩形的原点指针上。因为这样赋值的特性，矩形中的原点和point指向的同一内存空间，那么我们修改了point的值，矩形的origin当然也会跟着改变。那么为了避免这个问题，我们修改setOrigin方法的实现，代码如下： 

 

1 -(void) setOrigin:(XYPoint *) point
2 {
3     if(!origin){
4         origin=[[XYPoint alloc] init];
5     }
6 origin.x=point.x;
7 origin.y=point.y;
8 }

 

但是我们却得到了如下错误： 

 


    这是因为在Rectangle.h中我们使用@class指令来标识XYPoint，而现在需要XYPoint的细节，那么就需要修改头文件，将@class指令改为#import即可。之后修改主函数如下： 

 

 1 #import "Rectangle.h"
 2 #import "XYPoint.h"
 3 
 4 int main(int argc, const char * argv[])
 5 {
 6 
 7     @autoreleasepool {
 8         Rectangle *rect=[Rectangle new];
 9         XYPoint *point=[XYPoint new];
10         
11         [point setX:10 andY:23];
12         
13         [rect setWidth:32 andHeight:36];
14         [rect setOrigin:point];
15 
16         NSLog(@"Origin at (%i, %i)",rect.origin.x,rect.origin.y);
17 
18         [point setX:23 andY:10];
19         NSLog(@"Origin at (%i, %i)",rect.origin.x,rect.origin.y);
20         
21     }
22     return 0;
23 }

 

 编译运行，得到如下结果： 


 

    这样就很合理了，原点就属于矩形自己的，称为它的一个属性了，再次修改坐标点不会对已有原点产生影响。但是问题又产生了，修改主函数如下： 

 

 1 #import "Rectangle.h"
 2 #import "XYPoint.h"
 3 
 4 int main(int argc, const char * argv[])
 5 {
 6 
 7     @autoreleasepool {
 8         Rectangle *rect=[Rectangle new];
 9         XYPoint *point=[XYPoint new];
10         
11         [point setX:10 andY:23];
12         
13         [rect setWidth:32 andHeight:36];
14         [rect setOrigin:point];
15 
16         NSLog(@"Origin at (%i, %i)",rect.origin.x,rect.origin.y);
17 
18         [point setX:23 andY:10];
19         NSLog(@"Origin at (%i, %i)",rect.origin.x,rect.origin.y);
20         
21         XYPoint *origin=rect.origin;
22         
23         origin.x=32;
24         origin.y=36;
25         
26         NSLog(@"Origin at (%i, %i)",rect.origin.x,rect.origin.y);
27     }
28     return 0;
29 }

 

 如果我们在这里又定义一个对象来获取矩形的原点，然后对其重新赋值，那么我们得到如下结果： 


 

    这是因为我们使用origin方法返回时直接返回矩形内的原点引用，那么对这个引用的修改必然导致了上述的结果。出于这种原因，我们要修改origin方法，使其返回一个对象的副本，从而使得对其的修改不影响原有值： 

 

1 -(XYPoint *) origin
2 {
3     XYPoint *point=[XYPoint new];
4     point.x=origin.x;
5     point.y=origin.y;
6     return point;
7 }

 

 注意这里返回时重新创建了一个对象，对于这种开销是否必要，还要根据实际情况来定。 
    在继承中，不能删除和减少方法，但可以通过覆盖来实现对方法的更改，还是前面的示例，定义ClassA和ClassB，代码如下：

 

1 #import <Foundation/Foundation.h>
2 
3 @interface ClassA : NSObject
4 {
5     int x;
6 }
7 -(void) initVar;
8 @end

 

 类A接口中我们只给出变量定义（为了子类可以使用）和初始化方法，其实现代码如下： 

 

1 #import "ClassA.h"
2 
3 @implementation ClassA
4 -(void) initVar
5 {
6     x=100;
7 }
8 @end

 

   这里我们就是实现initVar方法对变量x进行了简单的赋值。那么来看下ClassB的定义： 

 

1 #import "ClassA.h"
2 
3 @interface ClassB : ClassA
4 
5 -(void) initVar;
6 -(void) printVar;
7 @end

 

它继承自ClassA，并且比类A多了打印变量的方法，其实现代码如下： 

 

 1 #import "ClassB.h"
 2 
 3 @implementation ClassB
 4 -(void) initVar
 5 {
 6     x=200;
 7 }
 8 -(void) printVar
 9 {
10     NSLog(@"x = %i",x);
11 }
12 @end

 

  代码也很简单，就是对x变量的初始化和打印，那这里也是方法覆盖的体现，那来看测试代码： 

 

 1 #import "ClassB.h"
 2 
 3 int main(int argc, const char * argv[])
 4 {
 5 
 6     @autoreleasepool {
 7         ClassB *clsB=[ClassB new];
 8                 
 9         [clsB initVar];
10         [clsB printVar];
11     }
12     return 0;
13 }

 

  编译运行，即可得到如下结果： 


 

    那么可以看到这里我们创建了类B，并且调用类B的实现代码对变量进行赋值和打印。从而实现了方法覆盖。如果我们将测试代码改写如下： 

 

 1 #import "ClassB.h"
 2 
 3 int main(int argc, const char * argv[])
 4 {
 5 
 6     @autoreleasepool {
 7         ClassA *clsA=[ClassA new];
 8         ClassB *clsB=[ClassB new];
 9         
10         [clsA initVar];
11         [clsA printVar];
12         
13         [clsB initVar];
14         [clsB printVar];
15     }
16     return 0;
17 }

 

 显然这里类A是没有printVar方法的，那么会得到如下错误： 

 


    因此我们需要修改ClassA的代码，加入printVar方法即可。我们分别创建了类A和类B的对象，它们使用各自的initVar方法后就会初始化自己的x变量，之后再使用各自的printVar方法来打印x的值。clsA和clsB按照各自所属的类选择相应的方法，这就是Objective-C中面向对象的基础。 
    那么如果我们将printVar方法从ClassB中删除，会是怎样的效果？因为ClassB继承自ClassA，如果ClassA中也未定义printVar方法，显然这里会出现错误。但如果ClassA中定义了printVar方法，那么ClassB就会继承这个方法。运行测试代码，也会打印出200这个值。 
    继承中还有抽象类的概念，如果一个类的创建只是为了更好的创建子类，那么这个类可以叫做抽象类。这样的类中可以定义实例变量和方法，但是不希望任何人从该类来创建实例，比如NSObject。在这里，只要理解抽象类的含义就可以了。