Objective-C编程基础读书笔记(5)

概述第5章  复合 使用复合可以组合多个对象，让它们分工合作。在实际的程序中，你会同时用到继承和复合来创建自己的类，所以掌握这两个概念非常重要。 什么是复合 复合就是一个类持有另一个类的引用（默然说话：大多数面向对象理论书籍里的术语叫关联）。在Objective-C中，复合是通过包含作为实例变量的对象指针实现的。例如我们可以用一个Pedal（脚踏板）对象和一个Tire（轮胎）对象组合出虚拟的Unicy 第5章  复合

使用复合可以组合多个对象，让它们分工合作。在实际的程序中，你会同时用到继承和复合来创建自己的类，所以掌握这两个概念非常重要。

什么是复合

复合就是一个类持有另一个类的引用（默然说话：大多数面向对象理论书籍里的术语叫关联）。在Objective-C中，复合是通过包含作为实例变量的对象指针实现的。例如我们可以用一个Pedal（脚踏板）对象和一个Tire（轮胎）对象组合出虚拟的Unicycle（独轮车）。

@interface Unicycle:NSObject

{

    Pedal *pedal;

    Tire *tire;

}

@end //Unicycle

Car程序

现在准备搭建一个汽车模型。好吧，我们不会去费力地研究真正的汽车的物理模型，我们象这样考虑：1辆汽车只包含1台发动机和4个轮胎。轮胎和发动机都是仅包含一个方法的类，这个方法仅输出它们各自所代表的含义：轮胎对象会说它们是轮胎，发动机对象会说它是一台发动机。

CarParts程序的所有代码也是包含在main.m中。完整代码如下：

//

//  main.m

//  CarParts

//  类与类的关系：复合

//  Created by mouyong on 13-6-23.

//  copyright (c) 2013年 mouyong. All rights reserved.

//

#import <Foundation/Foundation.h>

@interface Tire : NSObject

@end //Tire

@implementation Tire

- (Nsstring *)description{

    return (@"我是一个轮胎");

}//description

@end//Tire

@interface Engine : NSObject

@end//Engine

@implementation Engine

- (Nsstring *)description{

    return @"我是一个发动机";

}//description

@end//Engine

@interface Car : NSObject

{

    Engine *engine;

    Tire *tires[4];

}

-(voID)print;

@end//Car

@implementation Car

- (ID) init{

    if (self=[super init]) {

        engine=[Engine new];

        tires[0]=[Tire new];

        tires[1]=[Tire new];

        tires[2]=[Tire new];

        tires[3]=[Tire new];

    }

    return self;

}//init

- (voID) print{

    NSLog(@"%@",engine);

    NSLog(@"%@",tires[0]);

    NSLog(@"%@",tires[1]);

    NSLog(@"%@",tires[2]);

    NSLog(@"%@",tires[3]);

}//print

@end//Car

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

{

    Car *car;

    car=[Car new];

    [car print];

    return 0;

}//main

在Tire类中只有一个description方法，比较奇怪的是，它并没有在接口中声明。它是从哪儿来的？如果接口中并没有包含它，计算机又怎么能知道可以在Tire类里调用description方法呢？（默然说话：感觉description就象Java中的toString()）

为SNLog定义输出字符串

NSLog()可以使用%@格式说明符来输出对象。NSLog()处理%@说明符时，会调用对象的description方法，然后对象的description方法生成一个Nsstring并将其返回。NSLog()就会在输出结果中包含这个字符串。在类中提供description方法就可以自定义NSLog()会如何输出对象。

在自定义的description方法中，既可以写一个很简单的字符串，也可以使用各种形式连接一个复杂的字符串。

Engine类也只有一个description方法。

最后一部分是Car本身，它拥有一个engine对象和一个由4个tire对象组成的数组。它通过复合的方式来组装自己。Car同时还有一个print()方法，该方法输出轮胎和发动机的描述。

因为engine和tires是Car类的实例变量，所以它们是复合的。你可以说汽车有4个轮胎和1个发动机。

@interface Car : NSObject

{

    Engine *engine;

    Tire *tires[4];

}

-(voID)print;

@end//Car

每一个Car对象都会为指向engine和tires的指针分配内存，但是真正包含在Car中的并不是engine和tires变量，只是内存中存在的其他对象的引用指针。为新建的Car对象分配内存时，这些指针将被初始化为nil(默然说话：相当于Java中的null值。)，也就是说这辆汽车现在既没有发动机也没有轮胎，但预留的安装发动机和轮胎的位置，只是还没装上去。

下面让我们在看看Car类的实现。首先是一个初始化实例变量的init方法。（默然说话：注意到声明中并没有声明init吧？直觉告诉我，这个方法应该是Java中的构造方法吧）该方法为我们的汽车创建了用来装配的1个engine和4个tire变量。使用new创建新对象时，系统其实在后台执行了两个步骤：第一步，为对象分配内存，即对象获得一个用来存放实例变量的内存块；第二步，自动调用init方法，使该对象进入可用状态。

Car类的init方法创建了4个新轮胎并赋值给tires数组，还创建了一台发动机并赋值给engine实例变量。

在init方法中比较奇怪的是那个if语句，我们解释一下这行代码的意思。为了让父类将所有需要的初始化工作一次性完成，你需要调用[super init]。意思是让父类初始化过程中返回的对象与一开始创建的保持一致。而将初始化返回的结果赋给self是Objective-C的惯例。

@implementation Car

- (ID) init{

    if (self=[super init]) {

        engine=[Engine new];

        tires[0]=[Tire new];

        tires[1]=[Tire new];

        tires[2]=[Tire new];

        tires[3]=[Tire new];

    }

    return self;

}//init

- (voID) print{

    NSLog(@"%@",tires[3]);

}//print

@end//Car

最后一部分是main()函数，也是程序的驱动力。main()函数创建了一辆新车，并告诉它输出自身的信息，然后退出程序。

生成并运行CarParts程序，你应该会看到与下面内容类似的输出：

-------------------------------------------------------------------------------------------------------------------

2013-06-27 10:01:18.312 CarParts[16183:303]我是一个发动机

2013-06-27 10:01:18.314 CarParts[16183:303]我是一个轮胎

2013-06-27 10:01:18.315 CarParts[16183:303]我是一个轮胎

2013-06-27 10:01:18.315 CarParts[16183:303]我是一个轮胎

2013-06-27 10:01:18.316 CarParts[16183:303]我是一个轮胎

-------------------------------------------------------------------------------------------------------------------

存取方法

我们可以使用存取方法来改进CarParts。

经验丰富的编程人员看到Car类的init方法可能会问：“为什么汽车要自己创建轮胎和发动机呢？”如果用户能为汽车定做不同类型的轮胎和发动机，那么这个程序就会更完善了。

我们可以添加存取方法来实现上述想法。存取（accessor）方法是用来读取或改变某个对象属性的方法。例如前面Shapes-Object中的setFillcolor:就是一个存取方法。如果添加一个新方法去改变Car对象中的engine对象变量，那它就是一个存取方法。因为它为对象中的变量赋值，所以这类存取方法被称为setter方法。你也许听说过mutator方法，它是用来更改对象状态的。

另一种存取方法当然是getter方法。getter方法为代码提供了通过对象自身访问对象属性的方式。在赛车游戏中，物理逻辑引擎可能会想要读取汽车轮胎的属性，以此来判断赛车以当前的速度行驶是否会在湿滑的道路上打滑。

说明：如果要对其他对象中的属性进行 *** 作，应该尽量使用对象提供的存取方法，绝对不能直接改变对象里面的值。例如，main()函数不应直接访问Car类的engine实例变量(通过car->engine的方法)来改变engine的属性，而应使用setter方法进行更改。

存储方法是程序间接工作的另一个例子。使用存取方法间接地访问car对象中engine，可以让car的实现更为灵活。

下面为Car添加一些setter和getter方法，这样它就有选用轮胎和发动机的自主权了。下面是Car类的新接口。

@interface Car : NSObject

{

    Engine *engine;

    Tire *tires[4];

}

-(Engine *)engine;

-(voID)setEngine:(Engine *)newEngine;

-(Tire *)tireAtIndex:(int) index;

-(voID)setTire:(Tire *) tire atIndex:(int)index;

-(voID)print;

@end//Car

代码中的实例变量并没有变化，但是新增了两对方法：engine和setEngine:用来处理发动机的属性，tireAtIndex和setTire:atIndex：用来处理轮胎的属性。存取方法总是成对出现的，一个用来设置属性的值，另现代战争用来读取属性的值。有时只有一个getter方法（用于只读属性）或者只有一个setter方法（只写属性）也是合理的。但通常情况下，我们都会同时编写setter和getter方法。

对于存取方法的全名，Cocoa有自己的惯例。

setter方法根据它所更改的属性的名称来命名，并加上前缀set。

getter方法则是以其返回的属性名称命名，不要将get用作getter方法的前缀。

说明 get这个词在Cocoa中有着特殊的含义。如果get出现在Cocoa的方法名称中，就意味着这个方法会将你传递的参数作为指针来返回数值。

如果你在存取方法的名称中使用了get，那么有经验的Cocoa编程人员就会习惯性地将指针当做参数传入这个方法，当他们发现这不过是一个简单的存取方法时就会感到困惑。最好不要让其他编程人员被你的代码搞得一头雾水。（默然说话：作为一个有经验的Java编程人员，在看到getter方法不写get前缀时我感到非常困惑，我现在已经一头雾水啦~~）

设置engine属性的存取方法

第一对存取方法用来访问发动机的属性：

-(Engine *)engine;

-(voID)setEngine:(Engine *)newEngine; 

在代码中调用Car对象的engine方法可以访问engine变量，调用setEngine:方法可以更改发动机的属性。下面是实现代码：

-(Engine *)engine{

    return engine;

}//engine

-(voID) setEngine:(Engine *)newEngine{

    engine=newEngine;

}//setEngine

getter方法engine返回实例变量engine的当前值。记住，在Objective-C中所有对象间的交互都是通过指针实现的，所以方法engine返回的是一个指针，指向Car中的发动机对象。

同样，setter方法setEngine:将实例变量engine的值赋为参数所指向的值。实际上被复制的并不是engine变量，而是指向engine的指针值。换一种方式说，就是在调用了对象Car中的setEngine:方法后，依然只存在一个发动机，而不是两个。

说明   为了信息的完整性，我们需要说明，在内存管理和对象所有权方面，Engine的getter方法和setter方法还存在着问题。但是现在就把内存管理和对象生命周期管理的问题摆出来，肯定会让你困惑和沮丧，所以我们把如何准确无误的编写存取方法放到第8章再讲。

设置tires属性的存取方法

tires的存取方法稍微复杂一点：

-(Tire *)tireAtIndex:(int) index;

-(voID)setTire:(Tire *) tire atIndex:(int)index;

由于汽车的4个轮胎都有自己不同的位置（汽车车体的4个角落各有一个轮胎），所以Car对象中包含一个轮胎的数组。在这里我们需要用索引存取器而不能直接访问tires数组。所以在为汽车配置轮胎时，不仅需要知道是哪个轮胎，还要清楚每个轮胎在汽车上的位置。同样，当访问汽车上的某个轮胎时，访问的也是这个轮胎的具体位置。

下面是相关存取方法的实现代码：

-(Tire *)tireAtIndex:(int)index{

    if (index <0 || index>3) {

        NSLog(@"错啦 索引值%d不对！",index);

        exit(1);

    }

    return (tires[index]);

}//tireAtIndex

-(voID)setTire:(Tire *)tire atIndex:(int)index{

    if (index <0 || index>3) {

        NSLog(@"错啦 索引值%d不对！",index);

        exit(1);

    }

    tires[index]=tire;

}//setTire:atIndex

tire存取方法检查了tires实例变量的数组索引，以保证它是有效的。如果传入的索引值不在0到3的范围，程序将会输出错误信息并退出。这就是所谓防御式编程（defensive programming）,这是种很好的编程思想。防御式编程能够在开发早期发现错误，比如tires数组的索引错误。

Car类代码的其他变化

首先Car类的init方法。由于Car现在已经有访问engine和tires变量的方法，所以init方法就不需要再创建这两个变量了，这样一来，init方法都可以去除（默然说话：当然，你要保留它也行，这样程序就多一种选择，既可以弄到一辆已经装配好的车，又可以随时更换轮胎和发动机），因为已经不需要在Car中做这些工作了。新车的车主会得到一辆没有轮胎和发动机的汽车，可以自己装配它。

接着我们可以更新一下main()函数，如下：

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

{

    Car *car;

    car=[Car new];

    Engine *engine=[Engine new];

    [car setEngine:engine];

    for (int i=0; i<4; i++) {

        Tire *tire=[Tire new];

        [car setTire:tire atIndex:i];

    }

    [car print];

    return 0;

}//main

从用户的角度来看，程序的运行结果并没有任何改变。

扩展CarParts程序

既然Car类已经有了存取方法，就应该充分利用它。我们不会照搬当前的发动机和轮胎，而是对这些部件做一些改变。用集成方式来创建新的发动机和轮胎，然后使用Car类的存取方法（复合方式）给汽车配置新的部件。

首先创建一个新型的发动机Slant6。

@interface Slant6 : Engine

@end//Slant6

@implementation Slant6

-(Nsstring *)description{

    return (@"我是一个Slant6发动机！");

}//description

@end//Slant6

@H_404_946@

@H_404_946@

Slant6是发动机，所以它是Engine的子类。要记住，继承可以让我们在需要父类的的地方使用子类。在Car类中，setEngine:方法需要的是Engine型的参数，所以我们可以放心的传递Slant6型的参数。

在Slant6类中，description方法被重写，用来输出新信息。由于Slant6并没有调用父类中的description方法，所以新信息完全替代了继承自Engine的描述信息。

轮胎的新类AllWeatherRadial的实现步骤与创建Slant6的步骤非常相似。将其定义为现有类Tire的子类，然后重写description方法。

@interface AllWeatherRadial : Tire

@end//AllWeatherRadial

@implementation AllWeatherRadial

-(Nsstring *)description{

    return @"我是一个全天候轮胎";

}//description

最后调整main()函数，使用痛苦的型的发动机和轮胎

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

{

    Car *car;

    car=[Car new];

    Engine *engine=[Slant6 new];

    [car setEngine:engine];

    for (int i=0; i<4; i++) {

        Tire *tire=[AllWeatherRadial new];

        [car setTire:tire atIndex:i];

    }

    [car print];

    return 0;

}//main

main()仅仅是重新new了两个新类，其他部分并无改动，然后我们就发现输出已经完全变了。

----------------------------------------------------------------------------------------------------------------------

2013-07-06 10:16:38.476 CarParts[576:303] 我是一个Slant6发动机！

2013-07-06 10:16:38.478 CarParts[576:303] 我是一个全天候轮胎

2013-07-06 10:16:38.478 CarParts[576:303] 我是一个全天候轮胎

2013-07-06 10:16:38.479 CarParts[576:303] 我是一个全天候轮胎

2013-07-06 10:16:38.479 CarParts[576:303] 我是一个全天候轮胎

----------------------------------------------------------------------------------------------------------------------

复合还是继承

CarParts同时用到了继承和复合，也就是我们在前一章和本章中所介绍的两个“万能”工具。那么，什么时候用继承，什么时候用复合？

继承的类之间建立的关系为“是”的关系，三角形是形状，Slant6是发动机，AllWeatherRadial是轮胎。所以，如果可以说“X是Y”，那么就可以使用继承。

复合的类之间建立的关系为“有”。形状有颜色，汽车有发动机和轮胎。与继承的区别：汽车不是发动机，也不是轮胎。所以，如果可以说“X有Y”，那就可以使用复合。

新手在进行面向对象编程时通常会犯这样的错误：对任何东西都想使用继承，例如让Car类继承Engine类。这样的确可以让代码正常运行，但是其他人阅读这段代码时会不理解：汽车是发动机？！当然不是。所以只应在适当的时机使用继承。

小结

复合是OOP的基础概念，我们通过这种技巧来创建引用其他对象的对象。例如，汽车对象引用了1个发动机和4个轮胎对象。在本章关于复合的讨论中，我们介绍了存取方法，它既为外部对象提供了改变其属性的途径，同时又能保护实例变量本身。

存取方法和复合是密不可分的，因为我们通常都会为复合的对象编写存取方法。我们还学习了两种类型的存取方法：setter方法和getter方法，前者告诉对象将属性改为什么，后者要求对象提供属性的值。

本章还介绍了Cocoa存取方法的命名规则。需要特别指出的是，对于返回属性值的存取方法，名称中不能使用get这个词。

下一章我们不会谈论任何OOP理论，而是介绍如何分割不同的类，并将它们放入多个源文件中，而不是把所有代码都写到一个大文件里。

本人接受个人捐助，如果你觉得文章对你有用，并愿意对默然说话进行捐助，数额随意，默然说话将不胜感激。

总结

以上是内存溢出为你收集整理的Objective-C编程基础读书笔记(5)全部内容，希望文章能够帮你解决Objective-C编程基础读书笔记(5)所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。