iOS中都有什么设计模式？各个设计模式的作用？

标签：

一  iOS中都有什么设计模式？

1.代理模式

2.观察者模式

3.MVC模式

4.单例模式

5.策略模式

6.工厂模式

二  各个设计模式的作用？

（一）代理模式

在观察者模式中，一个对象任何状态的变更都会通知另外的对改变感兴趣的对象。这些对象之间不需要知道彼此的存在，这其实是一种松耦合的设计。当某个属性变化的时候，我们通常使用这个模式去通知其它对象。

此模式的通用实现中，观察者注册自己感兴趣的其它对象的状态变更事件。当状态发生变化的时候，所有的观察者都会得到通知。苹果的推送通知（Push Notification）就是一个此模式的例子。

如果你要遵从MVC模式的概念，你需要让模型对象和视图对象在不相互直接引用的情况下通信。这正是观察者模式的用武之地。

Cocoa通过通知（Notifications）和Key-Value Observing(KVO)来实现观察者模式。

在cocoa框架中的Delegate模式中，委托人往往是框架中的对象（视图中的控件、表视图神马的），代理人往往是视图控制器对象。

在我们这个例子中UITableView是委托人，代理人首先得满足一个条件：就是在.h文件中申明它拥有代理资格：

@interface WhateverViewController < UITableViewDelegate >
@end

红色的表示这个视图控制器拥有UITableView的代理资格。

其次，在.m文件中定义委托人可以让代理人去代替做的事情：

//视图控制器来代办应该有多少个节
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
    return [NSArray count];
}
//视图控制器来代办某个节应该有多少行
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
    return [[NSArray objectAtIndex:section]count];
}
// 视图控制器来代办负责每个栏格的外观
- (UITableViewCell *)tableView:(UITableView *)tableView 
      cellForRowAtIndexPath:(NSIndexPath *)indexPath {
 
    static NSString *CellIdentifier = @"Cell";
 
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
    if (cell == nil) {
        cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault 
                reuseIdentifier:CellIdentifier] autorelease];
    }
 
    cell.textField.text = [NSArray objectAtIndex:indexPath.row]; 
 
    return cell;
}
//负责当栏格被点击后需要触发的事件
- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
    AnotherViewController *anotherViewController = [[AnotherViewController alloc]
                                                                         initWithNibName:@"AnotherView" bundle:nil];
    [self.navigationController pushViewController:anotherViewController];
    [anotherViewController release];
}
// 这个是可选的，视图控制器勤快我就帮你代办，不勤快我就可以不帮你办这事儿，(提供哪些个行可以被编辑)
- (BOOL)tableView:(UITableView *)tableView canEditRowAtIndexPath:(NSIndexPath *)indexPath {
    return YES;
}
// 对特定编辑风格进行操作
- (void)tableView:(UITableView *)tableView 
        commitEditingStyle:(UITableViewCellEditingStyle)editingStyle 
        forRowAtIndexPath:(NSIndexPath *)indexPath 
{
    if (editingStyle == UITableViewCellEditingStyleDelete) {
        [tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath] withRowAnimation:YES];
    }
    else if (editingStyle == UITableViewCellEditingStyleInsert) {
    }
}
// 可选，对那些被移动栏格作特定操作
- (void)tableView:(UITableView *)tableView moveRowAtIndexPath:(NSIndexPath *)fromIndexPath 
        toIndexPath:(NSIndexPath *)toIndexPath {
}
// 对那些可以移动的行返回YES
- (BOOL)tableView:(UITableView *)tableView canMoveRowAtIndexPath:(NSIndexPath *)indexPath {
    // 如果不想让栏格移动，就返回NO
    return YES;
}

 好了，当这个委托人需要办这些事时，代理人自己就站出来帮忙办了。这就是ios中的Delegate模式。

二、自定义的delegate模式

@interface A：UIView
id transparendValueDelegate;
@property(nomatic, retain) id transparendValueDelegate;

@end

@implementation A
@synthesize transparendValueDelegate

-(void)Call
{ 
NSString* value = @"你好";
[transparendValueDelegate transparendValue: value];
}

@end


@interface B：UIView

NSString* value;
@end



@implementation B
-(void)transparendValue:(NSString*)fromValue
{
value = fromValue;
NSLog(@"%@ ,我是B",value); 
}
@end

使用时：

A* a = [[A alloc] init];
B* b = [[B alloc] init];
a. transparendValueDelegate = b;//设置A代理委托对象为B
[a Call];

这样就会输出:

你好,我是B

 委托模式关键就在于一个“被”字。这个B是很被动的，随时就会被你A Call一下。

三、为什么会有delegate模式

换句话说，它可以用来解决神马问题？

当一个类的某些功能需要被别人来实现，但是既不明确是些什么功能，又不明确谁来实现这些功能的时候，委托模式就可以派上用场。

例如你可以再写个C类，实现-(void)transparendValue:(NSString*)fromValue {NSLog(@"%@ ,我是C",value); }也是完全可以的。换谁来，只要它实现了这个方法，我就可以委托它来做这个事。

说到底一切都是为了使类之间的耦合性更松散。好的代码应该对扩展开放，对修改关闭。

总结来自http://blog.sina.com.cn/s/blog_b638dc89010192qu.html

（二）观察者模式

在软件开发中，无论是那种高级语言中总会伴随着一些最为常用的设计模式，即便就如iOS开发中与我们打交道最多的无非就是单例模式、观察者模式和工厂模式了，当然了其他的设置模式也同样存在在编程的很多地方。下面就就让我们简单的了解下观察者模式吧!

观察者模式本质上时一种发布-订阅模型,用以消除具有不同行为的对象之间的耦合，通过这一模式，不同对象可以协同工作，同时它们也可以被复用于其他地方Observer从Subject订阅通知，ConcreteObserver实现重现ObServer并将其重载其update方法。一旦SubJect的实例需要通知Observer任何新的变更，Subject会发送update消息来通知存储在其内部类中所注册的Observer、在ConcreteObserver的update方法的实际实现中，Subject的内部状态可被取得并进行后续处理。其类图如下:

 

观察者模式.png

由上面我们可以发现观察者模式无非在是定义对象间的一种一对多的依赖关系，并且当一个对象的状态发生改变的时候，所有依赖于它的对象都会得到通知且自动更新。即如果Subject允许其他观察者(实现了观察者接口的对象)对这个Subject的改变进行请阅，当Subject发送了变化，那么Subject会将这个变化发送给所有的观察者，观察者就能对Subject的变化做出更新。其时序图如下

 

观察者模式2.png

通过上面的观察我们可以发现如果用N个Observer来拓展Subject的行为，这些Observer具有处理存储在Subject中的信息的特定实现，这样也就实现了前面所说的消除不同对象间的耦合的功能了。

那么了解了这些我们可能就会更像了解下我们在什么时候才会去使用观察者模式呢？

• 当需要将改变通知所有的对象时，而你又不知道这些对象的具体类型
• 改变发生在同一个对象中，并需要改变其他对象将相关的状态进行更新且不知道有多少个对象。

而同样的在我们日常的开发中在Cocoa Touch框架中的的两种经常打交道的技术KVO与通知都实现了观察者模式，所以下面我们讨论的重点也就是基于这两个方面的。

通知

在之前的博文中曾经简单的提到过一些通知的基础使用方法，所以一些基本的使用方法再次就不赘述。言归正传，在Cocoa Touch框架中NSNotificationCenter和NSNotification对象实现了一对多的模型。通过NSNotificationCenter可以让对象之间进行通讯，即便这些对象之间并不认识。下面我们来看下NSNotificationCenter发布消息的方法:

   NSNotification  * subjectMessage = [ NSNotification  notificationWithName:@"subjectMessage"  object: self];
    NSNotificationCenter  * notificationCenter = [ NSNotificationCenter  defaultCenter];
    [notificationCenter postNotification:subjectMessage];

通过上面的代码我们创建了一个名为subjectMessage的NSNotification对象,然后通过notificationCenter来发布这个消息。通过向NSNotificationCenter类发送defaulCenter消息，可以得到NSNotificationCenter实例的引用。每个进程中只有一个默认的通知中心，所以默认的NSNotificationCenter是个单例对象。如果有其他观察者定于了其对象的相关事件则可以通过以下的方法来进行操作:

    NSNotificationCenter  * notificationCenter1 = [ NSNotificationCenter  defaultCenter];
    [notificationCenter addObserver: self  selector: @selector(update:) name:@"subjectMessage"  object: nil ];

经过以上步骤我们已经向通知中心注册了一个事件并且通过selector制定了一个方法update:下面我们可以实现以下这个方法

- (void)update:(NSNotification*)notification{

        if ([[notification name] isEqualToString:@"subjectMessage"]) {
            NSLog(@"%@",@"猴子派来的救兵去哪了？");

        }
}

当然最后如果我们需要对监听进行销毁

- (void)dealloc {
    [[NSNotificationCenter defaultCenter] removeObserver:self];
}

了解过通知之后我们来看一下KVO

KVO是Cocoa提供的一种称为键值观察的机制，对象可以通过它得到其他对象特定属性的变更通知。而这个机制是基于NSKeyValueObserving非正式些，Cocoa通过这个协议为所有遵循协议的对象提供了一种自动化的属性监听的功能。

虽然通知和KVO都可以对观察者进行实现，但是他们之间还是略有不同的，由上面的例子我们可以看出通知是由一个中心对象为所有观察者提供变更通知，主要是广义上关注程序事件，而KVO则是被观察的对象直接想观察者发送通知，主要是绑定于特定对象属性的值。下面我们通过一个简单的例子来了解下他的一些是使用方法

首先我们有Hero这个模型

@property (nonatomic,copy) NSString * name;
@property (nonatomic,copy) NSString * title;
@property (nonatomic,assign) NSUInteger age;

在控制其中我们将其初始化并赋值

    self.hero = [[Hero alloc] init];
    self.hero.name = @"赵云";
    self.hero.title = @"将军";
    self.hero.age = 87;

现在我们的这个对象基本有值了，那么我们将这个对象的name监听下他的改变

[self.hero addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew|NSKeyValueObservingOptionOld context:nil];

触发通知并将值改变

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event{
    self.hero.name = @"张飞";
}

在制定的回调函数中，处理收到的更改通知

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context{
    if([keyPath isEqualToString:@"name"])
    {
        NSLog(@"赋值后--%@",self.hero.name);
        NSLog(@"新的值--%@",change[@"new"]);
        NSLog(@"以前的值--%@",change[@"old"]);

    }
}

回调打印如下:

 

dayin.png

最后注销观察者

- (void)dealloc{
    [self.hero removeObserver:self forKeyPath:@"name"];
}

到了这里观察者模式中常用的KVO及通知的内容就到这里，不过要知道这里谈及的只是最基础的用法，后面我们可能还是有更加深入的探究，或者在后续中可能还会对比iOS中的代理以及Block来探寻下iOS中的消息传递机制，再或者像Swift中的didSet、willSet的属性监听的方法，这些都是很好玩的内容，不是么？

（三）MVC模式

MVC根据角色划分类，涉及到三个角色：

Model:模型保存应用程序的数据。

View：视图是模型的可视化表示以及用户交互的控件。

Controller:控制器是一个协调所有工作的中介者。它访问模型中的数据并在视图中展示它们，同时它们还监听事件和操作数据。

一个MVC模式的好的实现也就意味着每一个对象都会被划分到上面所说的组中。

我们可以很好的用下图来描述通过控制器实现的视图到模型的交互过程：

模型会把任何数据的变更通知控制器，然后控制器更新视图数据。视图对象通知控制器用户的操作，控制器要么根据需要来更新模型，要么检索任何被请求的数据。

你可能在想为什么不能仅仅使用控制器，在一个类中实现视图和模型，这样貌似更加容易？

所有的这些都归结于代码关注点分离以及复用。在理想的状态下，视图应该和模型完全的分离。如果视图不依赖某个实际的模型，那么视图就可以被复用来展示不同模型的数据。

举个例子来说，如果将来你打算加入电影或者书籍到你的资料库中，你仍然可以使用同样的AlbumView去显示电影和书籍数据。更进一步来说，如果你想创建一个新的与专辑有关联的工程，你可以很简单的复用Album类，因为它不依赖任何视图。这就是MVC的强大之处。

（四）单例模式

单例设计模式确保对于一个给定的类只有一个实例存在，这个实例有一个全局唯一的访问点。它通常采用懒加载的方式在第一次用到实例的时候再去创建它。

注意：苹果大量使用了此模式。例如：[NSUserDefaults standardUserDefaults], [UIApplication sharedApplication], [UIScreen mainScreen], [NSFileManager defaultManager]，所有的这些方法都返回一个单例对象。

你很可能会想为什么这么关心是否一个类有多个实例？毕竟代码和内存都是廉价的，对吗？ 

有一些情况下，只有一个实例显得非常合理。举例来说，你不需要有多个Logger的实例，除非你想去写多个日志文件。或者一个全局的配置处理类：实现线程安全的方式访问共享实例是容易的，比如一个配置文件，有好多个类同时修改这个文件。

（五）策略模式

（六）工厂模式

工厂模式我的理解是：他就是为了创建对象的

创建对象的时候，我们一般是alloc一个对象，如果需要创建100个这样的对象，如果是在一个for循环中还好说，直接一句alloc就行了，但是事实并不那么如意，我们可能会在不同的地方去创建这个对象，那么我们可能需要写100句alloc 了，但是如果我们在创建对象的时候，需要在这些对象创建完之后，为它的一个属性添加一个固定的值，比方说都是某某学校的学生，那么可能有需要多些100行重复的代码了，那么，如果写一个-(void)createObj方法，把创建对象和学校属性写在这个方法里边，那么就是会省事很多，也就是说我们可以alloc 创建对象封装到一个方法里边，直接调用这个方法就可以了，这就是简单工厂方法

代码结构如下

Animal 类

@interface Animal :NSObject

@proterty(nonatomic,strong) NSString *name;

-(void)laugh;

@end

Dog类

@interface Dog:Animal

@end

Cat类

@interface Cat:Animal

@end

创建对象的工厂类

.h

@interface AnimalFactory:NSObject

+(Dog *)createDog;

+(Cat *)createCat;

@end

.m

@implementation AnimalFactory

+(Dog *)createDog{

    Dog *dog=[[Dog alloc]init];

    dog.name=@“baby”;

    return dog;

}

+(Cat *) createCat{

    Cat *cat=[[Cat alloc]init];

    return cat;

}

Main.m文件

Dog *dog=[AnimalFactory createDog];

Cat *cat=[AnimalFactory createCat];

这是简单工厂模式

现在创建100个Dog对象，如果这100个对象写在程序中的不同地方，按上边的方法是需要把Dog *dog=[AnimalFactory createDog];这一句话写在程序中很多不同的地方，那么现在有一个需求，就是如果需要把这些创建的100个Dog对象全部变成Cat对象，那么按照刚才的那个做法，就需要在这100句代码中把createDog方法变成createCat方法了，这样做还是很复杂

那么这个时候用工厂方法模式就能解决这个难题了

工厂方法模式是为每一个要创建的对象所在的类都相应地创建一个工厂

代码如下

@interface AnimalFactory:NSObject

-(Animal*)createAnimal;

@end;

Dog工厂类

@interface DogFactory:AnimalFactory;

@implementation DogFactory

-(Animal *)createAnimal{

retrurn [[Dog alloc]init];

}

@end

Cat工厂类

@interface CatFactory:AnimalFactory;

@implementation Cat Factory

-(Animal *)createAnimal

retrurn [[Cat alloc]init];

}

@end

Main.m

AnimalFactory *dogFactory=[[DogFactory alloc]init];

Animal *animal1=[dogFactory createAnimal];

[animal1 laugh];

Animal *animal2=[dogFactory createAnimal];

[animal2 laugh];

…….

Animal *animal100=[dogFactory createAnimal];

[animal100 laugh];

这样话如果要把100个Dog改为Cat的话，只需要吧DogFactory改为CatFactory就可以了

但是工厂方法也有它的限制：

1.要创建的类必须拥有同一个父类

2.要创建的类在100个不同的地方所调用的方法必须一样

以上这些只是个人感悟，会有一些不足的地方，请大家帮忙改正，嘿嘿

iOS中都有什么设计模式？各个设计模式的作用？

标签：

原文地址：http://www.cnblogs.com/dxb123456/p/5479198.html