2019-01-09 16:53:11 qq_19678579 阅读数 1214

iOS中常用的几种设计模式



对象创建 接口适配 对象去耦 抽象集合 行为扩展 算法封装 性能与对象访问 对象状态
原型(Prototype) 适配器(Adapter) 中介者(Mediator) 组合(Composite) 访问者(Visitor) 模板方法(Template Method) 享元(Flyweight) 备忘录(Memento)
工厂方法(Factory Method) 桥接(Bridge) 观察者(Observer) 迭代器(Iterator) 装饰(Decorator) 策略(Strategy) 代理(Proxy) -
抽象工厂(Abstract Factory) 外观(Facade) - - 责任链(Chain of Responsibility) 命令(Command) -
生成器(Builder) - - - - - - -
单例(Singleton) - - - - - - -

目前常用的几种设计模式:代理模式、观察者模式、MVC模式、单例模式、策略模式、工厂模式、MVVM

1.代理模式

代理是一对一的,响应栈内最近一个代理对象(多为传值,相连的页面)
代理的使用,可以简单的概括为两个三步走,即创建代理的三步和使用代理的三步。 
创建代理:

  • 创建代理协议
  • 声明代理方法
  • 声明代理属性 
    使用代理:
  • 遵守代理协议
  • 设置代理对象
  • 实现代理方法 
    下面我们直接上代码,实现点击代理按钮,上面的label显示“代理传的值”

1.创建代理(传值的页面)

//.h文件中
#import <UIKit/UIKit.h>
//创建代理协议
@protocol RYTestDelegate <NSObject>
//声明代理方法
@optional
- (void)delegateTestName:(NSString *)name;
@end

@interface RYDelegateSecondViewController : UIViewController
////声明代理属性
@property (nonatomic, weak) id<RYTestDelegate> delegate;
@end


//.m文件中
-(void)clickedDeleBtn{
    NSLog(@"代理");
    //要传递的对象
    NSString *myText = @"代理传的值";
    if ([self.delegate respondsToSelector:@selector(delegateTestName:)]) {
        [self.delegate delegateTestName:myText];
    }
}

2.使用代理(接收值的页面)

#import "RYDelegateSecondViewController.h"   //创建了代理的页面

@interface RYDelegateViewController ()<RYTestDelegate>
@property(nonatomic ,strong) UILabel *textLabel;
@end


-(void)clickedNextBtn{
    RYDelegateSecondViewController *vc = [[RYDelegateSecondViewController alloc]init];
     vc.delegate = self;
    [self.navigationController pushViewController:vc animated:YES];
}


-(void)delegateTestName:(NSString *)name{
    self.textLabel.text = name;
    NSLog(@"传值回来====>>代理");
}

2. 观察者模式(通知机制,KVO机制)

观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时,会通知所有观察者对象,使它们能够自动更新自己。 简而言之,就是A和B,A对B的变化感兴趣,就注册A为观察者,当B发生变化时通知A,告知B发生了变化。这个也叫做经典观察者模式。

  1. 通知机制
  • 注册通知接收者的代码(A):
   //注册通知
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(registerCompletion:)
                                                 name:@"RegisterCompeletionNotification"
                                               object:nil];
    
-(void)registerCompletion:(NSNotification *)notification{
    NSDictionary *theData = notification.userInfo;
    NSString *username = [theData objectForKey:@"username"];
    NSLog(@"username = %@",username);
}

  • 投送通知的代码
-(void)clickedNotifitionCenterBtn{
    NSLog(@"通知");
    
    NSDictionary *dataDic = [NSDictionary dictionaryWithObject:@"通知值" forKey:@"username"];
    [[NSNotificationCenter defaultCenter] postNotificationName:@"RegisterCompeletionNotification"
                                                        object:nil
                                                      userInfo:dataDic];
}

问题1. object是干嘛的?是不是可以用来传值?
答:object是用来过滤Notification的,只接收指定的sender所发的Notification…传值请用userInfo,而不是object
问题2. iOS中,广播通知(broadcast notification)/本地通知(local notification)/推送通知(push notification)有什么区别和不同?
出了名字相似以外,广播通知和其他两个通知是完全不一样的: 广播通知是cocoatouch中观察者模式的一种机制, 实现应用内部多个对象的通信…本地通知和推送通知中的"通知"是一种"提示"…通过警告框,发出声音,振动和在应用图标上显示数组等,在计划时间到达时,本地通知通过本地iOS发出,推送通知由第三方程序发送给苹果远程服务器,再由远程服务器推送给iOS特定应用.

  1. KVO机制
    对象的属性变化时,通知会直接发送到观察者对象.
    可以用来实现 ,比如, UITableView滑动时导航自动变换颜色,或者,一个计算房贷的软件,当首付金额改变时,每月还款数目等数据相应自动改变等.
    这里来观察UITableView一个实例的contentOffset属性.
  • 监听系统的变化
-(void)addObserverMethod{
    //添加监听者
    [self.tabelview addObserver:self    //监听者
                     forKeyPath:@"contentOffset"  //被观察对象的属性字符串
                        options:NSKeyValueObservingOptionNew|NSKeyValueObservingOptionOld//设置.这里的设置表示把属性变换的新旧两个值都传递给观察者
                        context:nil];//上下文内容,c语言形式的任何指针类型
}


//监听属性变化时的回调
-(void)observeValueForKeyPath:(NSString *)keyPath //被观察的属性
                     ofObject:(id)object //被观察的对象
                       change:(NSDictionary<NSKeyValueChangeKey,id> *)change //字典类型包含了变化的内容,与options呼应
                      context:(void *)context //传递过来的上下文
{
     NSLog(@"=========>>>>>>>> %@  ========>>>>>>>旧值 %@   =====>>>>新值  %@ ",keyPath,(NSString *)change[NSKeyValueChangeOldKey], (NSString *)change[NSKeyValueChangeNewKey]);//通过change字典渠道变化的属性变化前或变化后的值.
}

//取消监听
-(void)dealloc{
    [self.tabelview  removeObserver:self forKeyPath:@"contentOffset"];
}

  • 监听之定义类的变化
- (void)viewDidLoad {
    [super viewDidLoad];
    self.woman = [[Woman alloc]init];
    // 注册观察者,被观察的对象是woman的name属性,观察者为self
    [self.woman addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew context:nil];
}

// 监听属性值发生改变后回调
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context {
    NSLog(@"%@的%@改变了",object,keyPath);
}

// 点击屏幕的时候改变woman的name
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    self.woman.name = @"二丫";
}


*** #ec2617 KVC (不是设计模式,只是个键值对编码方法)

KVC : 键值编码,是Key Value Coding 的简称,cocoa的标准组成部分,是一种可以直接通过字符串的名字(Key)来访问类属性的机制,而不是通过调用Setter方法、Getter方法进行访问。


KVC是一个用于间接访问对象属性的机制(只是通过字符串访问,而不是访问器方法去访问一个对象实例变量的机制),使用该机制不需要调用set或get方法和“->”方法访问成员变量,而是通过setValue:forKey: 和 valueForKey:方法进行成员变量的访问,将在内部查找名为_key或key的成员变量,如果找不到,就会报错。

/*
 取值
 */
// 通过key取值
- (id)valueForKey:(NSString *)key   
// 通过路径取值
- (nullable id)valueForKeyPath:(NSString *)keyPath  
// 找不到key抛出异常
- (nullable id)valueForUndefinedKey:(NSString *)key 

/* 
 修改
 */
// 对属性进行简单赋值
- (void)setValue:(nullable id)value forKey:(NSString *)key  
// 根据路径对属性赋值
- (void)setValue:(nullable id)value forKeyPath:(NSString *)keyPath 
// 找不到key的时候抛出异常
- (void)setValue:(nullable id)value forUndefinedKey:(NSString *)key
// 同时给多个属性进行赋值
- (void)setValuesForKeysWithDictionary:(NSDictionary<NSString *, id> *)keyedValues;

4. 单例

一个单例类,保证一个类仅有一个实例,在整个程序中只有一个实例,并且提供一个类方法供全局调用,在编译时初始化这个类,然后一直保存在内存中,到程序(APP)退出时由系统自动释放这部分内存。


在整个应用程序中,共享一份资源(这份资源只需要创建初始化1次),一般用于工具类。例如:登陆控制器,网络数据请求,音乐播放器等一个工程需要使用多次的控制器或方法。


如工具类、公共跳转类等经常调用的类,都会采用单例模式。

static LoginViewController * _instance = nil;
+(instancetype)sharedLoginHandle{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
           //    loginVC = [[LoginViewController alloc] init];
			     _instance= [[self alloc] init];
    });
	 return _instance;
}

5. 适配器()

适配器模式:将一个类的接口转换成客户端希望的另一个接口。适配器模式使得原来由于接口不兼容而不能一起工作的那些类可以一起工作。


基本上有两种实现适配器的方式。
第一种是通过集成来适配两个接口,这称为类适配器。类适配器是通过多重集成来实现的。
第二种是对象适配器,与类适配器不同,对象适配器不继承被适配者,而是组合了一个对它的引用。

简单讲适配器模式的作用就是在封装控件,接收数据的时候,数据通过中间的适配器处理后再传给控件,主要是在自定义控件时使用。

  • 对象适配器
  1. Adaptee 被适配者
//被适配者//源角色//适配者
#import <Foundation/Foundation.h>
@interface RYAdaptee : NSObject

@property (nonatomic, strong)NSString *name;

-(void)sayName;

@end


#import "RYAdaptee.h"
@implementation RYAdaptee

-(id)init{
    
    self = [super init];
    if(self)
    {
        _name = @"adaptee target";
    }
    return self;
}
-(void)sayName{
    
    NSLog(@"%@",self.name);
}

@end

  1. Target 目标代理协议
#import <Foundation/Foundation.h>

@protocol RYTarget <NSObject>

@required   //必要的
-(void)speakName;

@end

  1. Adapter 适配器
#import <Foundation/Foundation.h>
#import "RYTarget.h"
#import "RYAdaptee.h"

@interface RYAdapter : NSObject<RYTarget>

@property (nonatomic ,strong)RYAdaptee *adaptee;

@end


#import "RYAdapter.h"

@implementation RYAdapter

-(void)speakName  //目标中的代理方法
{
    [self.adaptee sayName];
}

@end

  1. 使用
//对象适配器
    RYAdaptee *adaptee = [RYAdaptee new]; //适配源
    RYAdapter *adapter = [RYAdapter new]; //适配器
    adapter.adaptee = adaptee;
    id<RYTarget> target = adapter;
    [target speakName];
  • 类适配器

6. 策略

策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

简而言之就是把控制其中的一大串 if...else... 或者 switch()单独抽出来写成一些列的算法文件, 减轻了ViewController的负担同时也简化操作,提高代码维护性。算法可以自由切换,避免使用多重条件判断,扩展性良好。
**注意事项: #e91e63 如果一个系统的策略多于四个,就需要考虑使用混合模式,解决策略类膨胀的问题。

  • 在UITextField的子类CustomField

#import <UIKit/UIKit.h>
#import "InputValidator.h"

@interface CustomField : UITextField
//抽象的策略
@property (nonatomic, strong) InputValidator *validator;

/**
 初始化textField
 @param frame frame
 @return 实例对象
 */
- (instancetype)initWithFrame:(CGRect)frame;

/**
 验证输入合法性
 @return 是否合法,不合法,读取InputValidator当中的errorMessage
 */
- (BOOL)validate;

@end
- (BOOL)validate {
    return [self.validator validateInput:self];
}
  • 创建一个验证策略的基类 InputValidator
#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>

@interface InputValidator : NSObject
/**
 策略的输入
 @param input input
 @return 如果为YES,表示测试通过,如果为NO,表示测试不通过
 */
- (BOOL)validateInput:(UITextField *)input;

//当validateInput为NO的时候,我们来读取errorMessage
@property (nonatomic, strong) NSString *errorMessage;

@end
#import "InputValidator.h"

@implementation InputValidator

- (BOOL)validateInput:(UITextField *)input {
    return NO;
}

@end
  • 创建 一个邮箱验证方法类EmailValidator,继承于验证策略的基类(InputValidator)

然后重写输入验证的验证方法

#import "EmailValidator.h"

@implementation EmailValidator

- (BOOL)validateInput:(UITextField *)input {
    if (input.text.length <= 0) {
        self.errorMessage = @"邮箱没有输入";
    }
    else{
       self.errorMessage = nil;
    }
    return self.errorMessage == nil ? YES : NO;
}
@end
  • 创建 一个手机验证方法类PhoneNumberValidator,继承于验证策略的基类(InputValidator)

然后重写输入验证的验证方法

#import "InputValidator.h"

@interface PhoneNumberValidator : InputValidator

//重载了父类的验证方法
- (BOOL)validateInput:(UITextField *)input;

@end
#import "PhoneNumberValidator.h"

@implementation PhoneNumberValidator

- (BOOL)validateInput:(UITextField *)input {
    
    if (input.text.length <= 0) {
        self.errorMessage = @"手机号没有输入";
    } else {
        if (input.text.length == 11 ) {
             self.errorMessage = nil;
        } else {
             self.errorMessage = @"请输入正确的手机号码";
        }
    }
    return self.errorMessage == nil ? YES : NO;
}

@end
  • 在 ViewController中使用策略
- (void)viewDidLoad {
    [super viewDidLoad];

    self.emailField             = [[CustomField alloc] initWithFrame:CGRectMake(30, 80, 300, 30)];
    self.emailField.placeholder = @"请输入邮箱";
    self.emailField.delegate    = self;
    self.emailField.validator   = [EmailValidator new];
    [self.view addSubview:self.emailField];
    
    
    self.phoneNumberField             = [[CustomField alloc] initWithFrame:CGRectMake(30, 80 + 40, 300, 30)];
    self.phoneNumberField.placeholder = @"请输入电话号码";
    self.phoneNumberField.delegate    = self;
    self.phoneNumberField.validator   = [PhoneNumberValidator new];
    [self.view addSubview:self.phoneNumberField];
    
}
	#pragma mark - 文本框代理
- (void)textFieldDidEndEditing:(UITextField *)textField {
    
    CustomField *customField = (CustomField *)textField;
    
    if ([customField validate] == NO) {
        
        NSLog(@"====================>>>>>>>>>>>>    %@",customField.validator.errorMessage);
    }
}

相当于在此ViewController的textFieldDidEndEditing:中写了

- (void)textFieldDidEndEditing:(UITextField *)textField {
 
 
    if(textField == 邮箱textField){
        if (textField.text.length <= 0) {
            NSLog(@"邮箱没有输入");
        }
        else{
            NSLog(@"");
        }
    }
    else  if(textField == 手机textField){
        if (textField.text.length <= 0) {
             NSLog(@"手机号没有输入");
        } else {
            if (textField.text.length == 11 ) {
                NSLog(@"");
            } else {
                 NSLog(@"请输入正确的手机号码") ;
            }
        }
    }
 
}

9. 装饰器(Decorator)

装饰器模式在不修改原来代码的情况下动态的给对象增加新的行为和职责,它通过一个对象包装被装饰对象的方法来修改类的行为,这种方法可以做为子类化的一种替代方法。
这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。
在Objective-C中,存在两种非常常见的实现:Category(类别)和Delegation(委托)。

10. 原型(Prototype)

使用原型实例指定创建对象的种类,并通过复制这个原型创建新的对象。

    NSArray *array = [[NSArray alloc] initWithObjects:@1, nil];
    NSArray *array2 = array.copy;

array 就是原型了,array2 以 array 为原型,通过 copy 操作创建了 array2。
当创建的实例非常复杂且耗时,或者新实例和已存在的实例值相同,使用原型模式去复制已经存在的实例效率更高。

DEMO源码

2019-11-28 17:14:49 zxf15735185131 阅读数 23

什么是MVC设计模式

    MVC是Model(M)-View(V)-Controller(C)的缩写,是一种常见的设计模式,在Java web中有使用,在IOS开发中是一种基本的设计模式。使用MVC设计模式来构建一个App的项目,会使得项目结构更加清晰,能够加快开发速度。

   MVC设计模式由三部分组成:

  1. Model:  Mode中存有数据。凡是存有数据的东西,都可以称为Model,例如model object,networking。
  2. View: 是App的界面。View只用来展示数据,不包含任何逻辑代码,因此通常可以复用。例如UILabel。
  3. Controller:  用来控制View和Model,通过代理模式实现。在理想情况下,控制器实体是不知道处理的view是那个,它是通过protocol进行数据交互。

MVC的具体组成部分

Model

mode层包含了app中的数据。这一层不仅包含了model类,而且包含了能够项目中的其他类和实例。

  1. 网络代码
  2. 持久化代码
  3. 解析代码
  4. 管理层和抽象层
  5. 数据源和代理
  6. 常量
  7. 帮助程序和扩展

View

当用户和App进行交互,就是跟view层进行交互,view层不应该包含任何业务逻辑。View层包括如下:

  1. UIView的子类
  2. UIKit/AppKit中的组件
  3. 核心动画
  4. 核心图形

Controller

Controller层是被复用最少的。Controller层的职责包括如下:

  1. 决定访问的目标:持久化或网络
  2. 该多久刷新一次应用程序
  3. 下一个屏幕是那个
  4. 如果程序进入后台程序,该怎么样处理
  5. 用户点击一个单元格,该做什么处理

可以将controller层看作一个app的大脑,它来决定接下来发生什么。

MVC的优势与劣势

优势

  • 将逻辑代码、试图、数据分离,分别组织到不同层内,项目结构清晰
  • 在改进页面和用户交互的同时不需要重新边写业务逻辑
  • 可维护性高

劣势

  • 破坏了一些好的软件设计规范
  • View Controller中有大量的代码
  • 较差的可测性,View Controller中混合了视图逻辑代码和业务逻辑代码

MVC的使用场景

APP在开发初期可以使用MVC设计模式,在开发过程中可能需要向其他设计模式转换。

 

2017-02-21 10:32:47 biangabiang 阅读数 517

iOS开发中有很多种设计模式,这篇文章写的是单例模式,其它设计模式后续会更新。。。

先来看看百度百科中对单例模式的定义:

单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点,可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制,“阻止”所有想要生成对象的访问。使用工厂方法来限制实例化过程。这个方法应该是静态方法(类方法),因为让类的实例去生成另一个唯一实例毫无意义。

1.第一句话说明了单例是一种设计模式,有很多人在面试被问到单例时经常说:单例是一个对象,它在程序运行中是唯一的。这是把单例的定义和作用混淆了,它的作用是保证程序运行过程中对象的唯一性,所以这点需要注意。

2.后面说的就是如何实现单例了,其中提到需要创建一个静态方法(类方法)这正是需要我们去做的

以下就是单例类中的写法,单例的写法有很多种,这里不一一介绍了

#import <Foundation/Foundation.h>

@interface Singleton : NSObject

+ (instancetype) singleton;

@end

#import "Singleton.h"

//创建一个静态变量
static Singleton * instance = nil;
@implementation Singleton

//通过此类方法创建对象,保证唯一性
+ (instancetype)singleton {
    
    //通过GCD实现对象只创建一次
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        
        instance = [[super allocWithZone:NULL] init];
    });
    return instance;
}

//防止通过【[Singleton alloc] init]创建对象,因此需要重写这个方法,
//因为调用alloc时会自动调用allocWithZone这个方法
+ (instancetype)allocWithZone:(struct _NSZone *)zone{
    
    
    return [Singleton singleton];
}

//防止通过copy和mutableCopy创建对象,安全起见,重写以下两个方法
- (id)copy {
    
    return self;
}
- (id)mutableCopy{
    
    return self;
}
@end

测试一下

//创建四个对象
    Singleton * singleton1 = [Singleton singleton];
    Singleton * singleton2 = [Singleton singleton];
    Singleton * singleton3 = [Singleton singleton];
    Singleton * singleton4 = [[Singleton alloc] init];

    //打印内存地址
    NSLog(@"%p----%p----%p----%p",singleton1, singleton2, singleton3, singleton4);
    

测试结果



打印出的内存地址都是相同的,说明创建的四个对象为同一对象,测试单例成功!!!





2016-03-07 20:40:10 bruceyou1990 阅读数 254
 我们在学习iOS程序开发的时候,经常会听说 代理模式/适配器模式。。。那么到底什么事设计模式呢,我在一开始也是很迷糊的,其实设计模式是面向对象编程的一种设计思想,是通过经验把解决某一类问题的方法的总结。

一, 常见的设计模式

(一)代理模式
需求分析:当一个类的某些功能需要由别的类来实现,但是又不确定具体会是哪个类实现。
委托(delegate)也叫代理是iOS开发中常用的设计模式。我们借助于protocol(参考博文:objective-c协议(protocol))可以很方便的实现这种设计模式。

优缺点:降低耦合度(耦合度 是一个抽象的名词 就是对某一件事的相关性 相关性越小 对象A改变对对象B的影响最小)
(二)观察者模式
需求分析:某一事件改变对多处有影响 一处改变 多次影响
实现逻辑:

                Notification通知中心

Notification通知 具体实现逻辑:

1,注册通知:addObserver
1 @selector(callBack)
2- (void)callBack{是发生通知之后要处理的函数}
2,发送通知:postNotificationName
接收通知

第一步,首先定义回调,即发生通知了我应该做啥事。

- (void)callBack{
    NSLog(@"我收到通知了!");
}

第二步,注册通知,这里处理一些事件(事件改变就该发送通知 比如团购项目地区《北京》 切换到《广州》 地区发生改变 就需要发送通知 切换到请求广州地区的数据)这里的地区就是我们通知关注的事件

[[NSNotificationCenter defaultCenter] addObserver: self
    selector: @selector(callBack)
    name: @"这里是自定义通知的名字 在触发通知  事件处理 都是通过这个名字 下面就是发送通知"
    object: nil];

第三部,发送通知,就是需要处理通知的地方 接收通知 然后做相应改变

//
- (void)getNotofocation{
    NSLog(@"获取通知");
    //发出通知
    [[NSNotificationCenter defaultCenter] postNotificationName:@"这里是自定义通知的名字 在触发通知  事件处理 都是通过这个名字" object:self];
}

(三)MVC模式
实现逻辑:
Model(模型)是应用程序中用于处理应用程序数据逻辑的部分。
  通常模型对象负责在数据库中存取数据。
View(视图)是应用程序中处理数据显示的部分。
  通常视图是依据模型数据创建的。
Controller(控制器)是应用程序中处理用户交互的部分。
  通常控制器负责从视图读取数据,控制用户输入,并向模型发送数据。
优势:使系统,层次清晰,职责分明,易于维护
(四)单例模式
需求分析:单例模式的意思就是只有一个实例。单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。这个类称为单例类。
实现逻辑:

1,为单例对象实现一个静态实例,并初始化,然后设置成nil
1 static SurveyRunTimeData *sharedObj = nil
2,实现一个实例构造方法检查上面声明的静态实例是否为nil
1 +(SurveyRunTimeData*)sharedInstance{
}
3,重写allocWithZone方法,用来保证其他人直接使用alloc和init试图获得一个新实力的时候不产生一个新实例
1 重写allocWithZone方法
4,适当实现allocWitheZone,copyWithZone,release和autorelease
1 适当实现allocWitheZone,copyWithZone,release和autorelease
下面我们按照上面的步骤来手写一个单例
static SurveyRunTimeData *sharedObj = nil; //第一步:静态实例,并初始化。


@implementation SurveyRunTimeData
+ (SurveyRunTimeData*) sharedInstance  //第二步:实例构造检查静态实例是否为nil
{
    @synchronized (self)//synchronized 线程锁死 同时只能有一个线程进行访问 注释1
    {
        if (sharedObj == nil)
        {
            [[self alloc] init];
        }
    }
    return sharedObj;
}

+ (id) allocWithZone:(NSZone *)zone //第三步:重写allocWithZone方法
{
    @synchronized (self) {
        if (sharedObj == nil) {
            sharedObj = [super allocWithZone:zone];
            return sharedObj;
        }
    }
    return nil;
}

- (id) copyWithZone:(NSZone *)zone //第四步
{
    return self;
}

- (id) retain
{
    return self;
}

- (unsigned) retainCount
{
    return UINT_MAX;
}

- (oneway void) release
{

}

- (id) autorelease
{
    return self;
}

- (id)init
{
    @synchronized(self) {
        [super init];//往往放一些要初始化的变量.
        return self;
    }
}

@end
代码注释:
注释1.synchronized(self)当两个并发线程访问同一个对象object中的这个synchronized(self)同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

注意事项:确保使用者只能通过 getInstance方法才能获得,单例类的唯一实例。


本文为Coder Bruce原创,转载需征得本人同意。

iOS 设计模式 - 桥接模式

博文 来自: Seal_Shile

iOS 设计模式 - 工厂模式

博文 来自: Seal_Shile

iOS 设计模式 - 装饰模式

博文 来自: Seal_Shile

iOS 设计模式 - 外观模式

博文 来自: Seal_Shile
没有更多推荐了,返回首页