什么是工厂模式
工厂模式是我们最常用的实例化对象模式了，根据已知条件或者参数，实例化你需要的对象。
工厂模式分为三种：简单工厂模式、工厂模式、抽象工厂模式
一、简单工厂模式
定义：专门定义一个类（工厂类）负责创建其他类（产品类）的实例，被创建的实例通常具有共同的父类。 一般可以由一个工厂类，根据传入的参数，动态的决定创建出哪一个产品类的实例。
结构图：实现是创建，虚线是继承关系
参与者：
工厂角色（Factory）：接受客户端的请求，通过请求负责创建相应的产品对象。
抽象产品角色（Product）:是工厂模式所创建对象的父类或是共同拥有的方法。
具体产品角色:工厂模式所创建的对象都是这个角色的实例（Product1或Produc2的实例）。
特点：
工厂类只有一个，它集中了所有产品创建的逻辑。
通常使用静态方法，这使得工厂类无法由子类继承，难以拓展。
二、工厂模式
定义：工厂方法使用OOP（object - Oriented Programming：面向对象编程）的多态性，将工厂和产品都抽象出一个基类，在基类中定义统一的方法，然后在具体的工厂中创建具体的产品。
多态性：一个父类可以有多个子类，每个子类在继承了父类的方法后，对该父类方法分别进行重写，那么每个子类的方法是不一样的，一个父类方法被改写成多种形态，叫做多态。
结构图：实现是创建，虚线是继承关系
参与者：
抽象工厂角色：是创建对象的工厂的父类（Factory）或者共同拥有的方法。
具体工厂角色：实现了抽象工厂方法的具体类（Factory1、Factory2），并且受到应用程序的调用以创建产品对象。
抽象产品角色：是工厂方法所创建对象的父类（Product）或是共同拥有的方法。
具体产品角色：这个角色实现了抽象产品角色所声名的方法。工厂方法所创建的对象都是某个具体产品角色（Product1、Product2）的实例。
特点：
降低了工厂类的内聚，满足了类之间的层次关系，符合面向对象设计中的单一职责原则。
有利于程序的拓展，每次需要一个新的产品，只需要新建一个具体工厂来生成新的产品。
三、抽象工厂模式
定义：抽象工厂与工厂方法的区别是，工厂方法中的具体工厂一般只生产一个或几个控件对象，而抽象工厂中的具体工厂生产的是一族控件对象。
抽象工厂屏蔽了内部的实现，最大好处在于，让你感觉不到内部差异性。NSString、NSNumber等都是使用了这种设计
抽象工厂模式与工厂模式的区别：
工厂模式：每个抽象产品派生多个具体产品类，每个抽象工厂类派生多个具体工厂类，每个具体工厂类负责一个具体产品的实例创建；
抽象工厂模式：每个抽象工厂派生多个具体工厂类，每个具体工厂负责多个（一系列）具体产品的实例创建。
结构图：实现是创建，虚线是继承关系
抽象工厂模式的参与者：
抽象工厂角色：担任这个角色的是工厂方法模式的核心。根据传入参数初始化不同具体工厂实例。
具体工厂角色：实现了抽象工厂方法的具体类，并且受到应用程序的调用以创建产品对象。
抽象产品角色：是工厂方法所创建对象的父类（Product、ProductPro）或是共同拥有的方法。
具体产品角色：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。
特点：
举例说明：
Factory
typedef NS_ENUM(NSInteger, FactoryProduteType) {
FactoryProduteType1,
FactoryProduteType2,
};
@interface Factory : NSObject
//简单工厂模式
//工厂（Factory）角色：接受客户端的请求，通过请求负责创建相应的产品对象。
+ (Product *)createProduct:(FactoryProduteType)fpType;
//工厂模式
+ (Product *)createProduct;
//抽象工厂模式
//接受客户端的请求，通过请求负责创建相应的工厂
+ (instancetype)factoryWithType:(FactoryProduteType)type;
- (Product *)ccreateProduct;
@end
@implementation Factory
+ (Product *)createProduct:(FactoryProduteType )fpType
{
//通过枚举返回不同的产品
Product *p;
switch (fpType) {
case FactoryProduteType1:
p = [[Product1 alloc] init];
break;
case FactoryProduteType2:
p = [[Product2 alloc] init];
break;
default:
return nil;
break;
}
return p;
}
+ (Product *)createProduct
{
Product *p = [[Product alloc] init];
return p;
}
+ (instancetype)factoryWithType:(FactoryProduteType)type
{
//通过枚举返回不同的工厂
Factory *f;
switch (type) {
case FactoryProduteType1:
f = [[Factory1 alloc] init];
break;
case FactoryProduteType2:
f = [[Factory2 alloc] init];
break;
default:
break;
}
return f;
}
- (Product *)ccreateProduct
{
Product *p = [[Product alloc] init];
return p;
}
@end
Factory1
@interface Factory1 : Factory
@end
@implementation Factory1
//工厂模式
+ (Product *)createProduct
{
Product *p = [[Product1 alloc] init];
return p;
}
//抽象工厂模式
- (Product *)ccreateProduct
{
Product *p = [[Product1 alloc] init];
return p;
}
@end
Factory2
@interface Factory2 : Factory
@end
@implementation Factory2
//工厂模式
+ (Product *)createProduct
{
Product *p = [[Product2 alloc] init];
return p;
}
//抽象工厂模式
- (Product *)ccreateProduct
{
Product *p = [[Product2 alloc] init];
return p;
}
@end
Product
@interface Product : NSObject
{
@protected
NSString *_product;
}
@property (nonatomic, copy, readonly)NSString *product;
- (void)productName;
@end
@implementation Product
- (void)productName
{
_product = @"Product";
NSLog(@"我是%@",_product);
}
@end
Product1
@interface Product1 : Product
@end
@implementation Product1
- (void)productName
{
_product = @"Product1";
NSLog(@"我是%@",_product);
}
@end
Product2
@interface Product2 : Product
@end
@implementation Product2
- (void)productName
{
_product = @"Product2";
NSLog(@"我是%@",_product);
}
@end
使用
//简单工厂模式
Product *p = [Factory createProduct:FactoryProduteType1];
[p productName];
//工厂模式
Product *p2 = [Factory1 createProduct];
[p2 productName];
//抽象工厂模式
Factory *f3 = [Factory factoryWithType:FactoryProduteType1];
Product *p3 = [f3 ccreateProduct];
[p3 productName];
打印结果：
我是Product1
我是Product1
我是Product1
工厂模式demo
https://github.com/BillowingCat/fatory
参考文档
https://www.jianshu.com/p/847af218b1f0
end:小编是很认真的写文哦，如果小编的文对您有用，一定要点“喜欢”哦！如果有问题欢迎评论
