承接上文iOS设计模式四(组合,迭代器)
本文为行为扩展--获取源码
目录
1 访问者模式
2 装饰模式
3 责任链模式
1 访问者模式
访问者模式是扩展组合结构功能的一种方式.
我们可以使用各种不同用途的访问者,以同样的方式访问这个组合结构,然后用访问者来处理增加的逻辑
当然,也可以用类的Extension来增加逻辑,但是一个访问者可以给多个类都增加逻辑,而用Extension则需要很多个了
一个给车升级的例子:
首先要有车OSZCars.h:
#import <Foundation/Foundation.h>
#import "OSZEngine.h"
#import "OSZWheel.h"
#import "OSZVisitor.h"
@interface OSZCars : NSObject
@property (nonatomic, strong) OSZEngine *engine;
@property (nonatomic, strong) NSMutableArray *wheels;
- (void)addWheels:(OSZWheel *)wheel atIndex:(NSUInteger)index;
//该方法是在加入访问者后添加的
- (void)acceptVisitor:(id<OSZVisitor>)visitor;
@end
值得注意的是- (void)acceptVisitor:(id<OSZVisitor>)visitor这个方法是在加入访问者后添加的
我们先把所有的模型建立完成再建立访问者来扩展
OSZCars.m:
#import "OSZCars.h"
@implementation OSZCars
- (instancetype)init
{
self = [super init];
if (self) {
self.wheels = [NSMutableArray array];
}
return self;
}
-(void)addWheels:(OSZWheel *)wheel atIndex:(NSUInteger)index
{
[self.wheels insertObject:wheel atIndex:index];
}
- (void)acceptVisitor:(id<OSZVisitor>)visitor
{
[self.engine acceptVisitor:visitor];
for (OSZWheel *wheel in self.wheels)
{
[wheel acceptVisitor:visitor];
}
}
@end
车有个引擎OSZEngine.h:
#import <Foundation/Foundation.h>
#import "OSZVisitor.h"
@interface OSZEngine : NSObject
@property (nonatomic, copy) NSString *name;
//接收访问者修改
- (void)acceptVisitor:(id<OSZVisitor>)visitor;
@end
OSZEngine.m:
#import "OSZEngine.h"
@implementation OSZEngine
- (void)acceptVisitor:(id<OSZVisitor>)visitor
{
[visitor visitEngine:self];
}
@end
车还有四个轮子OSZWheel.h:
#import <Foundation/Foundation.h>
#import "OSZVisitor.h"
@interface OSZWheel : NSObject
@property (nonatomic, assign) CGFloat size;
@property (nonatomic, copy) NSString *name;
//接收访问者修改
- (void)acceptVisitor:(id<OSZVisitor>)visitor;
@end
OSZWheel.m:
#import "OSZWheel.h"
@implementation OSZWheel
- (void)acceptVisitor:(id<OSZVisitor>) visitor
{
[visitor visitWheel:self];
}
@end
访问者协议OSZVisitor.h:
#import <Foundation/Foundation.h>
@class OSZEngine,OSZWheel;
@protocol OSZVisitor <NSObject>
- (void)visitEngine:(OSZEngine *)engine;
- (void)visitWheel:(OSZWheel *)wheel;
@end
接下来在我们要扩展功能的时候,创建一个访问者,实体类修理工
OSZRepairman.h:
#import <Foundation/Foundation.h>
#import "OSZVisitor.h"
@interface OSZRepairman : NSObject<OSZVisitor>
@property (nonatomic, copy) NSString *name;
-(void)visitEngine:(OSZEngine *)engine;
-(void)visitWheel:(OSZWheel *)wheel;
@end
OSZRepairman.m:
#import "OSZRepairman.h"
#import "OSZEngine.h"
#import "OSZWheel.h"
@implementation OSZRepairman
-(void)visitEngine:(OSZEngine *)engine
{
NSLog(@"修理工正在对%@升级",engine.name);
}
-(void)visitWheel:(OSZWheel *)wheel
{
NSLog(@"修理工正在对%@升级",wheel.name);
}
@end
接下来我们在控制器中创建车的实例,访问者对车的功能扩展
OSZTenVC.m
#import "OSZTenVC.h"
#import "OSZCars.h"
#import "OSZEngine.h"
#import "OSZWheel.h"
#import "OSZRepairman.h"
@interface OSZTenVC ()
@end
@implementation OSZTenVC
- (void)viewDidLoad {
[super viewDidLoad];
OSZEngine *engine1 = [[OSZEngine alloc]init];
engine1.name = @"引擎1号";
OSZWheel *wheel1 = [[OSZWheel alloc]init];
wheel1.name = @"轮胎1";
OSZWheel *wheel2 = [[OSZWheel alloc]init];
wheel2.name = @"轮胎2";
OSZWheel *wheel3 = [[OSZWheel alloc]init];
wheel3.name = @"轮胎3";
OSZWheel *wheel4 = [[OSZWheel alloc]init];
wheel4.name = @"轮胎4";
OSZCars *car = [[OSZCars alloc]init];
car.engine = engine1;
[car addWheels:wheel1 atIndex:0];
[car addWheels:wheel2 atIndex:1];
[car addWheels:wheel3 atIndex:2];
[car addWheels:wheel4 atIndex:3];
NSLog(@"%@",car.engine.name);
//引擎1号
[car.wheels enumerateObjectsUsingBlock:^(id _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
OSZWheel *wheel = obj;
NSLog(@"%@",wheel.name);
}];
//轮胎1
//轮胎2
//轮胎3
//轮胎4
//访问者
OSZRepairman *man = [[OSZRepairman alloc]init];
[car acceptVisitor:man];
//修理工正在对引擎1号升级
//修理工正在对轮胎1升级
//修理工正在对轮胎2升级
//修理工正在对轮胎3升级
//修理工正在对轮胎4升级
}
@end
可以看出,一旦对组合结构实现了访问者模式,通常就不需要再修改各组合结构的接口,
其实也是相当于把各个组合结构要扩展的逻辑集中在了访问者中,在没有复用的情况下,代码的总量是一定的
2 装饰模式
我们向对象添加东西,在用的时候可以装饰上,不用的时候不破坏其原有的逻辑,
添加的东西都可以随时添加或者删除
有两种方式可以实现这个模式:子类和分类
处理图片的例子:获取源码
该协议定义了一种图片数据结构OSZPhotoProtocol.h
#import <Foundation/Foundation.h>
@protocol OSZPhotoProtocol <NSObject>
//漂亮等级
@property (nonatomic, assign) int beauty;
//宽高
@property (nonatomic, assign) int width;
@property (nonatomic, assign) int height;
//展示属性
- (void)show;
@end
装饰器根类OSZPhoto.h
#import <Foundation/Foundation.h>
#import "OSZPhotoProtocol.h"
@interface OSZPhoto : NSObject<OSZPhotoProtocol>
//保存图片
@property (nonatomic, strong) id<OSZPhotoProtocol> photo;
//处理图片的方法
- (id)initWithPhoto:(id<OSZPhotoProtocol>)photos;
@end
OSZPhoto.m
#import "OSZPhoto.h"
@implementation OSZPhoto
@synthesize beauty,width,height;
- (id)initWithPhoto:(id<OSZPhotoProtocol>)photos
{
if (self = [super init])
{
self.photo = photos;
}
return self;
}
- (void)show
{
NSLog(@"漂亮等级%d,宽%d,高%d",self.photo.beauty,self.photo.width,self.photo.height);
}
@end
2.1先通过子类来实现:
OSZPhotoMeiYan.h是空的
#import "OSZPhoto.h"
@interface OSZPhotoMeiYan : OSZPhoto
@end
OSZPhotoMeiYan.m
#import "OSZPhotoMeiYan.h"
@implementation OSZPhotoMeiYan
- (id)initWithPhoto:(id<OSZPhotoProtocol>)photos
{
// 另一种实现方式,把自己当做图片处理,而不是持有一个图片加工
// self = photos;
// self.beauty += 100;
// return self;
if (self = [super initWithPhoto:photos])
{
self.photo = photos;
}
return self;
}
- (void)show
{
self.photo.beauty += 100;
NSLog(@"漂亮等级%d,宽%d,高%d",self.photo.beauty,self.photo.width,self.photo.height);
}
@end
OSZPhotoEdit.h也是空的
#import "OSZPhoto.h"
@interface OSZPhotoEdit : OSZPhoto
@end
OSZPhotoEdit.m
#import "OSZPhotoEdit.h"
@implementation OSZPhotoEdit
- (id)initWithPhoto:(id<OSZPhotoProtocol>)photos
{
// self = photos;
// self.width += 100;
// self.height += 100;
// return self;
if (self = [super initWithPhoto:photos])
{
self.photo = photos;
}
return self;
}
- (void)show
{
self.photo.width += 100;
self.photo.height += 100;
NSLog(@"漂亮等级%d,宽%d,高%d",self.photo.beauty,self.photo.width,self.photo.height);
}
@end
2.2 通过分类来实现
OSZPhoto+MeiYan.h
#import "OSZPhoto.h"
@interface OSZPhoto (MeiYan)
- (instancetype)showWithMeiYan;
@end
OSZPhoto+MeiYan.m
#import "OSZPhoto+MeiYan.h"
@implementation OSZPhoto (MeiYan)
- (instancetype)showWithMeiYan
{
self.beauty += 100;
NSLog(@"漂亮等级%d,宽%d,高%d",self.beauty,self.width,self.height);
return self;
}
@end
OSZPhoto+Edit.h
#import "OSZPhoto.h"
@interface OSZPhoto (Edit)
- (instancetype)showWithEdit;
@end
OSZPhoto+Edit.m
#import "OSZPhoto+Edit.h"
@implementation OSZPhoto (Edit)
- (instancetype)showWithEdit
{
self.width += 100;
self.height += 100;
NSLog(@"漂亮等级%d,宽%d,高%d",self.beauty,self.width,self.height);
return self;
}
@end
控制器OSZElevenVC.m
#import "OSZElevenVC.h"
#import "OSZPhoto.h"
#import "OSZPhotoMeiYan.h"
#import "OSZPhotoEdit.h"
#import "OSZPhoto+MeiYan.h"
#import "OSZPhoto+Edit.h"
@interface OSZElevenVC ()
@end
@implementation OSZElevenVC
- (void)viewDidLoad
{
[super viewDidLoad];
self.view.backgroundColor = [UIColor blueColor];
//正常使用
OSZPhoto *p1 = [[OSZPhoto alloc]init];
p1.beauty = 100;
p1.width = 100;
p1.height = 100;
p1.photo = p1;
[p1 show]; //漂亮等级100,宽100,高100
//1.通过真正的子类实现装饰模式
//装饰1 美颜
OSZPhotoMeiYan *p2 = [[OSZPhotoMeiYan alloc]initWithPhoto:p1];
[p2 show]; //漂亮等级200,宽100,高100
//装饰2 修改大小
OSZPhotoEdit *p3 = [[OSZPhotoEdit alloc]initWithPhoto:p2.photo];
[p3 show]; //漂亮等级200,宽200,高200
//2.通过分类实现装饰模式
//装饰1 美颜
OSZPhoto *p4 = [p1 showWithMeiYan]; //漂亮等级300,宽200,高200
//装饰2 修改大小
OSZPhoto *p5 = [p4 showWithEdit]; //漂亮等级300,宽300,高300
}
@end
可以看出子类与分类的使用区别:
在子类中,图片是一个抽象类型,被子类持有加工,比较结构化,是原始风格
在分类中,图片是本身直接被加工,比较简单轻便,适用于少量装饰
当然,二者都可以实现另一种方式,这个例子仅仅是一个简单的演示,可能并不能看出来优点与好处,也可能并不贴切,仅仅是我个人的理解吧
具体如何在项目中使用,可能已经在不知不觉中就使用了,比如分类,延展,等等方式
一个很有意思的报错:
在非init或init开头方法中使用[super init]
错误信息如下：
error：Cannot assign to 'self' outside of a method in the init family
原因：
只能在init方法中给self赋值，Xcode判断是否为init方法规则：方法返回id，并且名字以init+大写字母开头+其他为准则
3 责任链模式
这种模式允许我们对整体结构功能的升级或者扩展,而不必修改已有单元的功能,只要添加链就行了
看起来跟装饰模式有点像,但实现不同的目的,实现方式也不同
主要方式为:
当前对象持有同父类下另一对象,另一对象可以继续持有其他对象,每个对象都重载相同的方法,当前对象处理不了,就返回给父类,父类再传给另一子类对象处理
模仿盾牌防御攻击的例子:获取源码
首先创建一个攻击父类OSZAttack方便使用,再创建几个子攻击类
火攻击:OSZFireAttack 冰攻击:OSZIceAttack 电攻击:OSZLightingAttack
这几个类都是空的,仅仅使用个类名,就不做繁琐的逻辑了
再创建一个防御父类
OSZAttackHandler.h
#import <Foundation/Foundation.h>
#import "OSZAttack.h"
@interface OSZAttackHandler : NSObject
//攻击处理者
@property (nonatomic, strong) OSZAttackHandler *nextAttackHandler;
//传递攻击
- (void)transmitAttack:(OSZAttack *)attack;
@end
OSZAttackHandler.m
#import "OSZAttackHandler.h"
@implementation OSZAttackHandler
- (void)transmitAttack:(OSZAttack *)attack
{
[self.nextAttackHandler transmitAttack:attack];
}
@end
火攻击防御者OSZFireHandler.h
#import "OSZAttackHandler.h"
@interface OSZFireHandler : OSZAttackHandler
//在子类的头文件中再次声明重写的方法不是必需的,但是这样做更加清楚
@end
OSZFireHandler.m
#import "OSZFireHandler.h"
#import "OSZFireAttack.h"
@implementation OSZFireHandler
- (void)transmitAttack:(OSZAttack *)attack
{
//如果是火攻击就拦截下来
if ([attack isKindOfClass:[OSZFireAttack class]])
{
NSLog(@"我拦截住了火攻击");
}
//如果不是就返回给父类,再去给别的人处理
else
{
NSLog(@"我挡不住这个攻击");
[super transmitAttack:attack];
}
}
@end
为了简化代码,冰防御者OSZIceHandler.h同样没有重写声明,什么也没有
OSZIceHandler.m
#import "OSZIceHandler.h"
#import "OSZIceAttack.h"
@implementation OSZIceHandler
- (void)transmitAttack:(OSZAttack *)attack
{
//如果是冰攻击就拦截下来
if ([attack isKindOfClass:[OSZIceAttack class]])
{
NSLog(@"我拦截住了冰攻击");
}
//如果不是就返回给父类,再去给别的人处理
else
{
NSLog(@"我挡不住这个攻击");
[super transmitAttack:attack];
}
}
@end
最后一个子类,作为化身,不做防御,处理最后的结果
OSZAvatar.h中什么也没有
OSZAvatar.m
#import "OSZAvatar.h"
@implementation OSZAvatar
- (void)transmitAttack:(OSZAttack *)attack
{
NSLog(@"我被打到了🐰❄️");
}
@end
控制器OSZTwelveVC
#import "OSZTwelveVC.h"
#import "OSZFireAttack.h"
#import "OSZIceAttack.h"
#import "OSZLightingAttack.h"
#import "OSZFireHandler.h"
#import "OSZIceHandler.h"
#import "OSZAvatar.h"
@interface OSZTwelveVC ()
@end
@implementation OSZTwelveVC
- (void)viewDidLoad {
[super viewDidLoad];
//创建一个人物,分配责任链
OSZAvatar *handler1 = [[OSZAvatar alloc]init];
//加火防御
OSZFireHandler *handler2 = [[OSZFireHandler alloc]init];
handler2.nextAttackHandler = handler1;
//加冰防御
OSZIceHandler *handler3 = [[OSZIceHandler alloc]init];
handler3.nextAttackHandler = handler2;
//开始攻击测试,选择最后一个责任链人物 先走冰防御,再走火防御
//先用火
OSZFireAttack *fire = [[OSZFireAttack alloc]init];
[handler3 transmitAttack:fire];
//我挡不住这个攻击
//我拦截住了火攻击
//再用冰
OSZIceAttack *ice = [[OSZIceAttack alloc]init];
[handler3 transmitAttack:ice];
//我拦截住了冰攻击
//再用电
OSZLightingAttack *lighting = [[OSZLightingAttack alloc]init];
[handler3 transmitAttack:lighting];
//我挡不住这个攻击
//我挡不住这个攻击
//我被打到了🐰❄️
}
@end
实际上我们完全可以把所有的逻辑都塞在一个类中达到目的,但如果逻辑很庞大的话,就会很乱,
而这三种模式,都是在扩展类逻辑的同时,进行最少的修改甚至不修改
