1.工厂方法模式定义?
定义一个用于创建对象的统一的接口(协议),然后由子类进行实现.
我只定义工厂规范,具体哪一个工厂,你就创建对应产品.
为什么这么做?
目的就是解除耦合
2.我们进行案例分析
- 第一种
我们首先创建接口(协议)工厂
#import <Foundation/Foundation.h>
#import "IProduct.h"
//工厂接口(协议)
@protocol IFactory01 <NSObject>
//定义一个规范
-(id<IProduct>)createProduct;
接着创建接口(协议)产品
#import <Foundation/Foundation.h>
@protocol IProduct <NSObject>
//产品规范:实现由具体的产品决定
-(void)method;
@end
接着创建具体的产品1
#import <Foundation/Foundation.h>
#import "IProduct.h"
//具体产品1
@interface ConcreateProduct1 : NSObject<IProduct>
@end
#import "ConcreateProduct1.h"
@implementation ConcreateProduct1
-(void)method{
NSLog(@"我是产品1");
}
@end
接着创建具体的产品2
#import <Foundation/Foundation.h>
#import "IProduct.h"
@interface ConcreateProduct2 : NSObject<IProduct>
@end
#import "ConcreateProduct2.h"
@implementation ConcreateProduct2
-(void)method{
NSLog(@"我是产品2");
}
@end
我们创建具体工厂1
#import <Foundation/Foundation.h>
#import "IFactory01.h"
@interface ConcrateFactory1 : NSObject<IFactory01>
@end
#import "ConcrateFactory1.h"
#import "ConcreateProduct1.h"
#import "ConcreateProduct2.h"
@implementation ConcrateFactory1
-(id<IProduct>)createProduct{
return [[ConcreateProduct1 alloc]init];
}
@end
案例一:
客户端不需要关心到底是哪一个产品,我们只需要工厂,
目的解除耦合,和具体产品解除了耦合,
提高了开发效率
- 第二种
案例一:存在什么问题?
问题:这个产品由内部控制,我们如果希望创建由客户端决定,同时达到解耦合的目的,我们该怎么办呢?
其实解决办法呢?是我上一篇文章的解决办法,如果你看了,或许就明白了.我们的解决办法就是动态创建实例对象.
我们先创建工厂协议和产品协议
#import <Foundation/Foundation.h>
#import "IProcut02.h"
@protocol IFactory02 <NSObject>
//定义一个规范
-(id<IProcut02>)createProduct:(NSString *)productClassName;
@end
#import <Foundation/Foundation.h>
@protocol IProcut02 <NSObject>
//产品规范:实现由具体的产品决定
-(void)method;
@end
创建具体产品1 和2
#import <Foundation/Foundation.h>
#import "IProcut02.h"
@interface ConcrateProduct102 : NSObject<IProcut02>
@end
#import "ConcrateProduct102.h"
@implementation ConcrateProduct102
-(void)method{
NSLog(@"我是产品1");
}
@end
#import <Foundation/Foundation.h>
#import "IProcut02.h"
@interface ConcrateProduct202 : NSObject<IProcut02>
@end
#import "ConcrateProduct202.h"
@implementation ConcrateProduct202
-(void)method{
NSLog(@"我是产品2");
}
@end
创建具体工厂
#import <Foundation/Foundation.h>
#import "IFactory02.h"
#define PRODUCT_1_02 @"ConcrateProduct102"
#define PRODUCT_2_02 @"ConcrateProduct202"
@interface ConcrateFactory02 : NSObject<IFactory02>
@end
#import "ConcrateFactory02.h"
@implementation ConcrateFactory02
-(id<IProcut02>)createProduct:(NSString *)productClassName{
return [[NSClassFromString(productClassName) alloc]init];
}
@end
案例二就做到了动态创建实例对象,我们只需要根据需要创建的产品,动态创建实例对象.
- 第三种
我们是否可以再次优化?
当然可以,我们选择工厂生产产品
先创建工厂协议与产品协议
#import <Foundation/Foundation.h>
#import "IProduct03.h"
@protocol IFactory03 <NSObject>
//定义一个规范
-(id<IProduct03>)createProduct;
@end
#import <Foundation/Foundation.h>
@protocol IProduct03 <NSObject>
//产品规范
-(void)method;
@end
创建具体产品1和具体工厂1
#import <Foundation/Foundation.h>
#import "IProduct03.h"
@interface ConcrateProduct103 : NSObject<IProduct03>
@end
#import "ConcrateProduct103.h"
@implementation ConcrateProduct103
-(void)method{
NSLog(@"我是产品1");
}
@end
#import <Foundation/Foundation.h>
#import "IFactory03.h"
@interface ConcrateFactory103 : NSObject<IFactory03>
@end
#import "ConcrateFactory103.h"
#import "ConcrateProduct103.h"
@implementation ConcrateFactory103
//工厂1用于创建产品1
-(id<IProduct03>)createProduct{
return [[ConcrateProduct103 alloc]init];
}
@end
创建具体产品2 和工厂产品2
#import <Foundation/Foundation.h>
#import "IProduct03.h"
@interface ConcrateProduct203 : NSObject<IProduct03>
@end
#import "ConcrateProduct203.h"
@implementation ConcrateProduct203
-(void)method{
NSLog(@"我是产品2");
}
@end
#import <Foundation/Foundation.h>
#import "IFactory03.h"
@interface ConcrateFactory203 : NSObject<IFactory03>
@end
#import "ConcrateFactory203.h"
#import "ConcrateProduct203.h"
@implementation ConcrateFactory203
//工厂2用于创建产品2
-(id<IProduct03>)createProduct{
return [[ConcrateProduct203 alloc]init];
}
@end
通过再次优化,选择具体工厂生产产品
第四种:
为了加深印象,我们再次举例.那我们生活中的案例进行扩展.
1.电脑协议2.电脑工厂3.具体产品4.具体工厂
首先创建电脑协议及电脑工厂
#import <Foundation/Foundation.h>
#import "IComputer.h"
@protocol IComputerFactory <NSObject>
//生产电脑
-(id<IComputer>)createComputer;
@end
#import <Foundation/Foundation.h>
//电脑规范
@protocol IComputer <NSObject>
//处理器
-(void)cpu;
//显卡
-(void)displaycard;
//主板
-(void)mainboard;
@end
接着创建具体工厂及具体产品
#import <Foundation/Foundation.h>
#import "IComputer.h"
@interface ComputerA : NSObject<IComputer>
@end
#import "ComputerA.h"
@implementation ComputerA
//处理器
-(void)cpu
{
NSLog(@"Intel i7");
}
//显卡
-(void)displaycard
{
NSLog(@"Intel 显卡");
}
//主板
-(void)mainboard
{
NSLog(@"三星主板");
}
@end
#import <Foundation/Foundation.h>
#import "IComputerFactory.h"
@interface FactoryA : NSObject<IComputerFactory>
@end
#import "FactoryA.h"
#import "ComputerA.h"
@implementation FactoryA
-(id<IComputer>)createComputer{
return [[ComputerA alloc]init];
}
@end
通过电脑工厂案例,你应该进一步了解了工厂方法模式的应用.
3.分析工厂方法模式:角色划分
第一个角色:抽象工厂
第二个角色:具体工厂
第三个角色:抽象产品
第四个角色:具体产品
4.工厂方法模式的UML图
工厂方法模式UML
具体产品实现抽象产品协议
具体工厂实现抽象工厂协议
具体工厂与具体产品之间存在依赖关系
5.总结
如果你了解了工厂方法模式,想一想自己做开发使用的代码?
如果单纯的创建实例的对象,我们那些方法是不是很low了.
我们通过改进我们的代码,不仅开发效率也提高了不少,解除了耦合度.
文章和代码会继续更新,代码整理放到github.
如果你喜欢这篇文章,能帮助到你,请你继续关注.
网友评论