1.为什么学习设计模式
对于设计模式，我们并不陌生。一谈起设计模式，脑海里马上就想到单例模式，委托模式，观察者模式等等。而面试官们也通常把对“某某设计模式”的掌握程度作为考评求职者的重要指标之一。那么问题来了，为什么要学习设计模式呢？没有设计模式我们同样能够实现功能，为什么还要“多此一举”呢？原因很简单，所谓的设计模式，只是为了开发者更好地去理解程序，说白了代码是死的，它们本身没有什么设计模式可言，只是开发者为了更好地理解程序，总结了一些设计模式，为的是让代码看上去更有条理，也便于人们理解。
2.介绍几种比较常用的设计模式
单例模式
单例模式的应用场景
单例模式的作用是解决应用程序中只有一个实例的问题，这在我们设计中会经常遇到，比如应用程序启动时，应用状态由UIApplication类一个实例维护，还有NSUserDefaults和NSNotificationCenter等单例。
单例模式的具体实现
oc版
+(Singleton *)sharedInstance{
static Singleton *sharedSingleton = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
sharedSingleton = [[Singleton alloc] init];
});
return sharedSingleton;
}
swift版
private let sharedInstance = Singleton()
class Singleton: NSObject {
class var sharedManager: Singleton {
return sharedInstance;
}
}
委托模式
委托设计模式类图
委托模式的应用场景
在iOS开发中，用到的系统的UITextField或者UITableView等都是应用的委托模式设计的，我们自己在开发过程中也会经常遇到，比如一些保存个人信息的界面，将信息填写完成之后，便可采用委托的方式将信息回传到首界面展示个人信息。还有很多类子，在这里就不一一列举了。
委托模式的具体实现
这里举一个简单的类子，比如我一天只干三件事，吃饭，睡觉，工作，为了更好地工作和生活，我请了一个助理。要成为我的助理，需要实现一个协议，协议要求能够处理吃饭，睡觉，工作问题。通用类就是我(coderPeng类)，通过代理（delegate）属性保持委托对象的引用.委托对象(ViewController)就是我的助理，它实现了了协议coderPengDelegate.coderPengDelegate定义了三个方法:sleep,eat,work方法.
oc版
CoderPeng类中的代码
.h中的代码
@protocol CoderPengDelegate <NSObject>
@required
- (void)sleep;
- (void)eat;
- (void)work;
@end
@interface CoderPeng : NSObject
//weak修饰为了防止内存的"强引用循环",从而避免内存泄漏问题
@property (nonatomic,weak)id<CoderPengDelegate>delegate;
- (void)start;
@end
.m中的代码
-(void)start{
if (self.delegate && [self.delegate respondsToSelector:@selector(sleep)] && [self.delegate respondsToSelector:@selector(eat)] && [self.delegate respondsToSelector:@selector(work)]) {
[self.delegate sleep];
[self.delegate work];
[self.delegate eat];
}
}
ViewControler类中的代码
@interface ViewController ()<CoderPengDelegate>
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
CoderPeng *coderPeng = [[CoderPeng alloc] init];
coderPeng.delegate = self;
[coderPeng start];
}
#pragma mark 协议方法
-(void)sleep{
NSLog(@"睡觉");
}
- (void)eat{
NSLog(@"吃饭");
}
- (void)work{
NSLog(@"工作");
}
@end
swift版
CoderPeng类中的代码
protocol coderPengDelegate {
func sleep()
func eat()
func work()
}
class CoderPeng: NSObject {
var delegate:coderPengDelegate?
func start() {
self.delegate?.sleep()
self.delegate?.eat()
self.delegate?.work()
}
}
ViewController类中的代码
class ViewController: UIViewController,coderPengDelegate {
override func viewDidLoad() {
super.viewDidLoad()
let coderPeng = CoderPeng()
coderPeng.delegate = self
coderPeng.start()
}
//MARK:协议方法
func sleep() {
print("睡觉")
}
func eat() {
print("吃饭")
}
func work() {
print("工作")
}
}
观察者模式
观察者模式简述
观察者模式也叫发布/订阅模式，是MVC模式的重要组成部分，它有4个角色，具体如下:
1.抽象主题(Subject): 在swift中，抽象主题是一个协议，它是一个观察者集合容器，定义了添加观察者方法，移除观察者方法和为所有观察者发送通知的方法;
2.抽象观察者(Observer):在swift中，抽象观察者也是一个协议，它有一个更新方法;
3.具体观察者(ConcreteObserver):Observer协议的具体实现;
4.具体主题(ConcreteSubject):Subject协议的具体实现.
引入Subject和Observer这俩个协议之后，不仅提高了系统的可复用性，还降低了耦合度。
通知机制和KVO机制
在Cocoa Touch框架中，观察者模式的具体应用有俩个——通知机制和KVO机制，下面介绍这俩个机制:
通知机制
通知机制与委托机制不同，前者是”一对多“的对象之间的通信，后者是“一对一”的对象之间的通信。在通知机制中，对某个通知感兴趣的所有对象都可以成为接收者。
通知机制简单示例
在开发过程中，登录成功后通常需要刷新数据，这个需求就可以用通知机制来完成。具体实现代码如下:
oc版
登录界面的代码（写在登录成功之后）
//name:通知名称
[[NSNotificationCenter defaultCenter] postNotificationName:@"RefreshData" object:nil];
需要刷新界面的代码
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(loadData)name:@"RefreshData" object:nil];
//数据请求
-(void)loadData{
}
//移除通知
- (void)dealloc{
[[NSNotificationCenter defaultCenter] removeObserver:self name:@"RefreshData" object:nil];
}
swift版
登录界面的代码（写在登录成功之后）
NSNotificationCenter.defaultCenter().postNotificationName("refreshData", object: nil)
需要刷新界面的代码
NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(self.loadData), name: "refreshData", object: nil)
//数据请求
func loadData() {
}
//移除通知
deinit {
NSNotificationCenter.defaultCenter().removeObserver(self, name: "refreshData", object: nil);
}
KVO机制
KVO机制不像通知机制那样通过一个通知中心观察所有对象，而是在对象属性变化时将通知直接发送给观察者对象
KVO机制简单示例
监测应用程序状态变化，appStatus是我们要观察的对象的属性，示例代码如下
oc版
在AppStatusObserver类中的代码
@implementation AppStatusObersver
-(void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSString *,id> *)change context:(void *)context{
NSLog(@"%@ %@",keyPath,change[NSKeyValueChangeNewKey]);
}
在appDelagate类中的代码
@interface AppDelegate ()
@property (nonatomic,strong)NSString *appStatus;
@property (nonatomic,strong)AppStatusObersver *observer;
@end
@implementation AppDelegate
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
// Override point for customization after application launch.
self.observer = [[AppStatusObersver alloc] init];
[self addObserver:self.observer forKeyPath:@"appStatus" options:(NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld) context:nil];
self.appStatus = @"launch";
return YES;
}
- (void)applicationWillResignActive:(UIApplication *)application {
self.appStatus = @"inactive";
}
- (void)applicationDidEnterBackground:(UIApplication *)application {
self.appStatus = @"background";
}
- (void)applicationWillEnterForeground:(UIApplication *)application {
self.appStatus = @"foreground";
}
- (void)applicationDidBecomeActive:(UIApplication *)application {
self.appStatus = @"active";
}
- (void)applicationWillTerminate:(UIApplication *)application {
self.appStatus = @"terminate";
}
@end
swift版
在AppStatusObersver类中的代码
//重写该方法的目的是为了监测属性的变化情况
override func observeValueForKeyPath(keyPath: String?, ofObject object: AnyObject?, change: [String : AnyObject]?, context: UnsafeMutablePointer<Void>) {
print("--%@--%@",keyPath!,(change![NSKeyValueChangeNewKey] as! String))
}
在appDelegate类中的代码
//appStatus属性是我们观察的，用dynamic修饰表示该属性是在运行时动态派发的
dynamic var appStatus : NSString!
var observer:AppStatusObersver!
func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
self.observer = AppStatusObersver()
self.addObserver(self.observer, forKeyPath: "appStatus", options: [NSKeyValueObservingOptions.New,NSKeyValueObservingOptions.Old] , context: nil)
self.appStatus = "launch"
return true
}
func applicationWillResignActive(application: UIApplication) {
self.appStatus = "inactive"
}
func applicationDidEnterBackground(application: UIApplication) {
self.appStatus = "background"
}
func applicationWillEnterForeground(application: UIApplication) {
self.appStatus = "foreground"
}
func applicationDidBecomeActive(application: UIApplication) {
self.appStatus = "active"
}
func applicationWillTerminate(application: UIApplication) {
self.appStatus = "terminate"
}
MVC模式
MVC模式简介
MVC(Model-View-Controller 模型-视图-控制器),模式是相当古老的设计模式之一，MVC由三部分组成，这三部分作用如下:
1.模型: 保存应用数据的状态，回应视图对状态的查询，处理应用业务逻辑，完成应用的功能，将状态变化通知视图;
2.视图: 为用户展示信息并提供接口。用户通过视图向控制器发出动作请求，然后再向模型发出查询状态的申请，而模型状态的变化会通知给视图;
3.控制器:接收用户请求，根据请求更新模型。另外，控制器还会更新选择的视图，并将其作为对用户请求的回应。控制器是视图和模型的媒介，可以降低视图与模型的耦合度，使视图和模型的职责更加清晰，从而提高开发效率。
MVC模式模型图
