版本记录
| 版本号 | 修改时间 |
|---|---|
| V1.0 | 2017.04.24 |
前言
不管java、oc还是其他面向对象的语言，它们在设计模式上是相通的，不同的只是语法。下面我就详细的说一下oc中23种设计模式。再说之前先介绍两篇我查阅的github地址和博客，如下：
1、Github:Design-Pattern-For-iOS
2、地址
简述
下面简单说明23种设计模式。
| 设计模式 | 说明 |
|---|---|
| 1.策略模式-Strategy | 它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。 |
| 2.装饰模式-Decorator | 动态的给一个对象添加有一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。 |
| 3.代理模式-Proxy | 为其他对象提供一种代理以控制对这个对象的访问。 |
| 4.工厂方法模式-Factory method | 定义一个拥有创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。 |
| 5.原型模式-Prototype | 用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 |
| 6.模板方式模式-Template method | 定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 |
| 7.外观模式-Facade | 为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。 |
| 8.建造者模式-Builder | 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 |
| 9.观察者模式-Observer | 定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。 |
| 10.抽象工厂模式-Abstract Factory | 提供了一个创建一些列相关或相互依赖对象的接口，而无需指定它们具体的类。 |
| 11.状态模式-State | 当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。 |
| 12.适配器模式-Adapter | 将一个类的接口转换成客户希望的另外一个接口，adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 |
| 13.备忘录模式-Memento | 在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样以后就可将该对象恢复到原先保存的状态。 |
| 14.组合模式-Composite | 将对象组合成树形结构以表示“部分--整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。 |
| 15.迭代器模式-Iterator | 提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。 |
| 16.单例模式-Singleton | 保证一个类仅有一个实例，使它们都可以独立地变化。 |
| 17.桥接模式-Bridge | 将抽象部分与它的实现部分分离，使它们都可以独立地变化。 |
| 18.命令模式-Command | 将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。 |
| 19.职责链模式-Chain of Responsibility | 使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系，将这个对象连成一条链传递该请求，直到有一个对象处理它为止。 |
| 20.中介者模式-Mediator | 用一个中介对象来封装一系列的对象交互，中介者使各个对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 |
| 21.享元模式-Flyweight | 使用共享技术有效地支持大量细粒度的对象。 |
| 22.解释器模式-Interpreter | 给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示中解释语言汇中的句子。 |
| 23.访问者模式-Visitor | 表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。 |
设计模式的基本原则非常重要，只要真正深入地理解了设计原则，很多设计模式其实就是原则的应用而已，或许在不知不觉中就在使用设计模式了。
- 单一职责原则（SRP）:对一个类而言，只做一件事。
- 开放-封闭原则（OCP）:是说软件实体（类，模块，函数等等）应该可以拓展，但是不可修改。
- 依赖倒转原则（DIP）:A. 高层模块不应该依赖于底层模块，两个都应该依赖抽象。 B. 抽象不应该依赖细节，细节应该依赖抽象。
- 里氏代换原则（LSP）：子类必须能够替换掉它们的父类型。
- 迪米特法则（LoD）: 如果两个类不需要彼此直接通信，那么这两个类就不应当发生直接的相互作用，如果其中一个类需要调用另外一个类的某一个方法的话，可以通过第三者转发这个调用。
- 合成/聚合复用原则（CARP）：尽量使用合成/聚合，尽量不要使用类继承。
详述
一、策略模式——Strategy
先看一下文档结构。
策略模式
下面看详细代码。
1. HCDCashBase.h
#import
#import
@protocol HCDCashBase
//@property(nonatomic,assign)CGFloat money;
- (CGFloat)acceptCash:(CGFloat)cash;
@end
2. HCDCashNormal.h
#import
#import "HCDCashBase.h"
@interface HCDCashNormal : NSObject
@end
3. HCDCashNormal.m
#import "HCDCashNormal.h"
@implementation HCDCashNormal
//@synthesize money = _money;
- (CGFloat)acceptCash:(CGFloat)cash{
return cash;
}
@end
4. HCDCashRobate.h
#import
#import "HCDCashBase.h"
@interface HCDCashRobate : NSObject
- (instancetype)initWithMoneyRebate:(CGFloat)moneyRebate;
@end
5. HCDCashRobate.m
#import "HCDCashRobate.h"
@interface HCDCashRobate ()
@property (nonatomic, assign) CGFloat moneyRebate;
@end
@implementation HCDCashRobate
//@synthesize money = _money;
-(instancetype)initWithMoneyRebate:(CGFloat)moneyRebate{
self = [super init];
if (self) {
_moneyRebate = moneyRebate;
}
return self;
}
-(CGFloat)acceptCash:(CGFloat)cash{
return self.moneyRebate * cash;
}
@end
6. HCDCaseReturn.h
#import
#import "HCDCashBase.h"
@interface HCDCaseReturn : NSObject
- (instancetype)initWithMoneyReturn:(CGFloat)moneyReturn;
@end
7. HCDCaseReturn.m
#import "HCDCaseReturn.h"
@interface HCDCaseReturn ()
@property(nonatomic)CGFloat moneyReturn;
@end
@implementation HCDCaseReturn
//@synthesize money = _money;
- (instancetype)initWithMoneyReturn:(CGFloat)moneyReturn{
self = [super init];
if (self) {
_moneyReturn = moneyReturn;
}
return self;
}
- (CGFloat)acceptCash:(CGFloat)cash{
return cash - self.moneyReturn;
}
@end
8. HCDCashContext.h
#import
#import "HCDCashBase.h"
typedef NS_ENUM(NSInteger, HCDCashType){
CashTypeNormal = 0,
CashTypeRobate,
CashTypeReturn
};
@interface HCDCashContext : NSObject
- (instancetype)initWithCashSuper:(id)cashBase;
- (instancetype)initWithCashType:(HCDCashType)type;
- (CGFloat)getResult:(CGFloat)money;
@end
9. HCDCashContext.m
#import "HCDCashContext.h"
#import "HCDCaseReturn.h"
#import "HCDCashNormal.h"
#import "HCDCashRobate.h"
@interface HCDCashContext()
@property (strong, nonatomic) id cashSuper;
@end
@implementation HCDCashContext
- (instancetype)initWithCashSuper:(id)cashBase{
self = [super init];
if (self) {
self.cashSuper = cashBase;
}
return self;
}
- (instancetype)initWithCashType:(HCDCashType)type{
self = [super init];
if (self) {
if (type == CashTypeNormal) {
self.cashSuper = [[HCDCashNormal alloc]init];
// self.cashSuper.money = money;
}else if(type == CashTypeRobate){
self.cashSuper = [[HCDCashRobate alloc]initWithMoneyRebate:0.8];
// self.cashSuper.money = money;
}else if(type == CashTypeReturn){
self.cashSuper = [[HCDCaseReturn alloc]initWithMoneyReturn:5];
}
}
return self;
}
- (CGFloat)getResult:(CGFloat)money{
return [self.cashSuper acceptCash:money];
}
@end
10. ViewController.m
#import "ViewController.h"
#import "HCDCashContext.h"
#import "HCDCashNormal.h"
#import "HCDCashRobate.h"
#import "HCDCaseReturn.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
HCDCashContext *context = [[HCDCashContext alloc]initWithCashType:CashTypeNormal];
NSLog(@"结果是%f",[context getResult:100]);
HCDCashContext *contextReturn = [[HCDCashContext alloc]initWithCashType:CashTypeReturn];
NSLog(@"结果是%f",[contextReturn getResult:100]);
HCDCashContext *contextRobate = [[HCDCashContext alloc]initWithCashType:CashTypeRobate];
NSLog(@"结果是%f",[contextRobate getResult:100]);
}
@end
这里写了策略模式，相信大家都能看懂。就不多解释了，代码不难，就是列举了一种思维模式或者设计方式而已。
后记
这里先写一个策略模式，其他的待续哦，这里我要感谢其他作者分享的资料，谢谢大家对我的支持。