适配器模式

定义

适配器模式(Adapter Pattern) ：将一个接口转换成客户希望的另一个接口，适配器模式使接口不兼容的那些类可以一起工作，其别名为包装器(Wrapper)。

应用场景

• 接口不兼容（适配器模式）
• 可以重复使用的类，用于与一些彼此之间没有太大关联的一些类一起工作（适配器模式）

• 统一输出接口，输入的类型无法确定（适配器模式）

  模式结构

  适配器模式包含如下角色：

• Target：目标抽象类定义客户要用的特定领域的接口

• Adapter：适配器类可以调用另一个接口，作为一个转换器，对适配者和抽象目标类进行适配，它是适配器模式的核心
• Adaptee：适配者类是被适配的角色，它定义了一个已经存在的接口，这个接口需要适配
• Client：客户类中针对目标抽象类进行编程，调用在目标抽象类中定义的业务方法

  对象适配器

  

  类适配器

  

  区别

  类适配器与对象适配器是实现适配器模式的不同方式，但是达成的目的相同。

代码分析

将美元(被适配对象—>Adaptee)——>人民币(目标接口——>Target)
适配器将美元转成人民币(Adaper)

Target协议

#import <Foundation/Foundation.h>
@protocol TargetProtocal <NSObject>
- (NSInteger)getCNY;
@end

被适配对象Adaptee

// USDAdaptee.h
#import <Foundation/Foundation.h>
@interface USDAdaptee : NSObject
- (void)setUSD:(NSInteger)usd;
- (NSInteger)getUSD;
@end
// USDAdaptee.m
#import "USDAdaptee.h"
@interface USDAdaptee ()
@property (nonatomic, assign) NSInteger usd;
@end
@implementation USDAdaptee
- (void)setUSD:(NSInteger)usd {
    _usd = usd;
}
- (NSInteger)getUSD {
    return _usd;
}
@end

对象适配器

对象适配器使用的是组合的模式，适配器类实现Target协议，并且在适配器类中定义一个Adaptee的属性，重写协议返回对Adaptee属性对象做相应的转换操作，来达到让Adaptee适配Target的目的。

// CNYObjectAdapter.h
#import <Foundation/Foundation.h>
#import "USDAdaptee.h"
#import "TargetProtocal.h"
@interface CNYObjectAdapter : NSObject <TargetProtocal>
@property (nonatomic, strong) USDAdaptee* usd;
- (instancetype)initWithUSD:(USDAdaptee*)usd;
@end
// CNYObjectAdapter.m
#import "CNYObjectAdapter.h"
@implementation CNYObjectAdapter
- (instancetype)initWithUSD:(USDAdaptee*)usd {
    self = [super init];
    if (self) {
        _usd = usd;
    }
    return self;
}
- (NSInteger)getCNY {
    return _usd.getUSD * 6.8;
}
@end

类适配器

类适配器使用的是继承的模式，适配器类实现Target协议，并且该适配器类继承Adaptee类，在重写的Target协议方法中使用super调用Adaptee的方法做相应的转换操作，来达到让Adaptee适配Target的目的。

// CNYClassAdapter.h
#import <Foundation/Foundation.h>
#import "USDAdaptee.h"
#import "TargetProtocal.h"
@interface CNYClassAdapter : USDAdaptee <TargetProtocal>
@end
// CNYClassAdapter.m
#import "CNYClassAdapter.h"
@implementation CNYClassAdapter
- (NSInteger)getCNY {
    return [self getUSD] * 6.8;
}
@end

客户端

// 类适配器的使用
CNYClassAdapter* cnyClsAdapter = [CNYClassAdapter new];
[cnyClsAdapter setUSD:1000];
NSInteger cny = [cnyClsAdapter getCNY];
NSLog(@"CNYClassAdapter ==> cny = %@", @(cny));
// 对象适配器的使用
USDAdaptee* usd = [USDAdaptee new];
[usd setUSD:1000];
CNYObjectAdapter* cnyObjAdapter = [[CNYObjectAdapter alloc] initWithUSD:usd];
NSInteger cny2 = [cnyObjAdapter getCNY];
NSLog(@"CNYClassAdapter ==> cny = %@", @(cny2));
// 结果输出
//  CNYClassAdapter ==> cny = 6800
// CNYClassAdapter ==> cny = 6800

优点

• 将目标类和适配者类解耦，通过引入一个适配器类来重用现有的适配者类，而无须修改原有代码。
• 增加了类的透明性和复用性，将具体的实现封装在适配者类中，对于客户端类来说是透明的，而且提高了适配者的复用性。
• 灵活性和扩展性都非常好，通过使用配置文件，可以很方便地更换适配器，也可以在不修改原有代码的基础上增加新的适配器类，完全符合“开闭原则”。
• 类适配器优点：由于适配器类是适配者类的子类，因此可以在适配器类中置换一些适配者的方法，使得适配器的灵活性更强。

• 对象适配器优点：一个对象适配器可以把多个不同的适配者适配到同一个目标，也就是说，同一个适配器可以把适配者类和它的子类都适配到目标接口。

  缺点

• 类适配器：对于不支持多重继承的语言，一次最多只能适配一个适配者类，而且目标抽象类只能为抽象类，不能为具体类，其使用有一定的局限性，不能将一个适配者类和它的子类都适配到目标接口。

• 对象适配器：与类适配器模式相比，要想置换适配者类的方法就不容易。如果一定要置换掉适配者类的一个或多个方法，就只好先做一个适配者类的子类，将适配者类的方法置换掉，然后再把适配者类的子类当做真正的适配者进行适配，实现过程较为复杂。