十一回了趟老家,十一前工作一大堆忙成了狗,十一回来后又积累了一大堆又 忙成了狗,今天刚好抽了一点空开始写工厂方法模式
我看了《Head First 设计模式》P109--P133 这25页,讲述了我们为什么要用工厂模式,里面用做pizza的例子讲的特别细腻。看完了就能很清楚的知道为什么要用工厂模式。
年龄越大越不喜欢一知半解,深刻的了解某些未知的事或物以后,它再出现就不怕了
#'New'有什么不对劲?
在技术上,new没有错,这是语言的基础部分。真正的犯人是我们的老朋友 ‘改变’, 以及它是如何影响new使用的。
如果代码是通过接口而写,通过多态,可以与任何新类实现该接口。
但是当代码使用大量的具体类时,那就麻烦了,因为一旦加入新的具体类,就必须改变代码。意思是代码没 " 对修改关闭"。想用新的具体类来扩展代码,必须重新打开它。
这可咋办? 只能改代码
很明显,如果实例化某些具体类,将使orderPizza()出问题,没办法让orderPizza()对修改关闭,
但是咱们还是能很明显的看出哪些会变,哪些不会变,这个时候就可以考虑封装了,
上面这些引出了下面的简单工厂模式
#简单工厂模式
1)算是定义吧
简单工厂模式其实并不是一个模设计模式,反而比较像一种编程习惯,还请不要把这个习惯认为是“工厂模式”。
不要因为简单工厂不是一个真正的模式,就忽略它的用法。
2)类图
3)举个例子(java)
public class PizzaStore {
SimplePizzaFactory factory; public PizzaStore(SimplePizzaFactory factory){
this.factory=factory;
} public Pizza orderPizza(String type){
Pizza pizza;
pizza=factory.createPizza(type); pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
} ############################ public class SimplePizzaFactory {
public Pizza createPizza(String type){
Pizza pizza=null;
if(type.equals("cheese")){
pizza=new CheesePizza();
}else if (type.equals("greek")){
pizza=new GreekPizza();
}else if(type.equals("pepperoni")){
pizza=new PepperoniPizza();
}else if (type.equals("clam")){
pizza=new ClamPizza();
}else if (type.equals("veggie")){
pizza=new VeggiePizza();
}
return pizza;
}
} ########################################################
public abstract class Pizza {
String name;
String dough;
String sauce; void prepare(){
System.out.print("Preparing");
};
void bake(){
System.out.print("Baking");
};
void cut(){
System.out.print("cut");
};
void box(){
System.out.print("box");
}; } public class VeggiePizza extends Pizza{
} public class ClamPizza extends Pizza {
} public class PepperoniPizza extends Pizza {
} public class PepperoniPizza extends Pizza {
} ################################# public static void main(String[] args) {
PizzaStore store=new PizzaStore();
Pizza pizza=store.orderPizza("cheese");
System.out.println("eat Pizza");
}
4)举个例子(python)
#工厂方法模式
#引入
#匹萨生意火爆,现在有很多人要开加盟店,不同地区的加盟店口味有差异。PizzaStore有个不错的订单系统,希望所有加盟店对订单的处理一致。
各区域匹萨店之间的差异在于他们制作匹萨的风味(比如 NYStyle 饼薄, ChicagoStyle 饼厚等),我们现在让createPizza()来应对这些变化负责创建正确种类的匹萨。
做法是让PizzaStore的各个子类负责定义自己的createPizza()方法。所以我们会得到PizzaStore的具体类。
#定义
定义了一个创建对象的接口,但有子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。
所有工厂模式都是用来封装对象的创建。工厂方法模式(Factory Method Pattern) 通过让子类决定该创建的对象是什么,来达到对象创建的过程封装的目的。
原本是由一个对象负责所有具体的实例化,现在变成一群子类负责实例化
#类图
#举个例子(java)
public abstract class PizzaStore { public Pizza orderPizza(String type){
Pizza pizza;
pizza=createPizza(type); pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
abstract Pizza createPizza(String type); } ###########################################################
public class NYPizzaStore extends PizzaStore{
Pizza createPizza(String item){
if(item.equals("cheese")){
return new NYStyleCheesePizza();
}else if (item.equals("greek")){
return new NYStyleGreekPizza();
}else if(item.equals("pepperoni")){
return new NYStylePepperoniPizza();
}else if (item.equals("clam")){
return new NYStyleClamPizza();
}else if (item.equals("veggie")){
return new NYStyleVeggiePizza();
}else return null
} ########
public class ChicagoPizzaStore extends PizzaStore {
Pizza createPizza(String item){
if(item.equals("cheese")){
return new ChicagoStyleCheesePizza();
}else if (item.equals("greek")){
return new ChicagoStyleGreekPizza();
}else if(item.equals("pepperoni")){
return new ChicagoStylePepperoniPizza();
}else if (item.equals("clam")){
return new ChicagoStyleClamPizza();
}else if (item.equals("veggie")){
return new ChicagoStyleVeggiePizza();
}else return null;
} } ##########################################################
public abstract class Pizza {
String name;
String dough;
String sauce; void prepare(){ }
void bake(){ }
void cut(){ }
void box(){ }
} ##############
public class NYStyleCheesePizza extends Pizza {
public NYStyleCheesePizza(){
name="NY Style Sauce and Cheese Pizza";
dough="Thin Crust Dough";
sauce="Marinara Sauce"; }
} ######## public class NYStyleClamPizza extends Pizza { } ######
public class NYStyleGreekPizza extends Pizza{ } #### public class NYStylePepperoniPizza extends Pizza { }
####### public class NYStyleVeggiePizza extends Pizza { }
######### public class ChicagoStyleCheesePizza extends Pizza {
public ChicagoStyleCheesePizza(){
name="Chicago Style Sauce and Cheese Pizza";
dough="Thick Crust Dough";
sauce="Plum Tomato Sauce"; }
} #########
public class ChicagoStyleGreekPizza extends Pizza{ }
######## public class ChicagoStylePepperoniPizza extends Pizza { } #######
public class ChicagoStyleClamPizza extends Pizza{ }
######
public class ChicagoStyleVeggiePizza extends Pizza { } #####################################################################
public class javatest1 {
public static void main(String[] args) throws IOException,ClassNotFoundException{
PizzaStore nyStore=new NYPizzaStore();
PizzaStore chicagoStore=new ChicagoPizzaStore();
Pizza pizza=nyStore.orderPizza("cheese");
System.out.println("eat NYStylePizza"); pizza = chicagoStore.orderPizza("cheese");
System.out.println("eat ChicagoStylePizza");
}
}
#举个例子(python)
class Person(object):
def __init__(self,name):
self.name = name def work(self):
print(self.name+"工作开始了") axe = Stone_Factory().create_axe() axe.cut_tree() class Axe(object):
def __init__(self,name):
self.name = name def cut_tree(self):
print("使用%s斧头砍树"%self.name) class StoneAxe(Axe): def cut_tree(self):
print("使用石斧头砍树") class SteelAxe(Axe): def cut_tree(self):
print("使用铁斧头砍树") class Tree(object):
pass #工厂类
'''
class Factory(object):
@staticmethod
def create_axe(type):
if type == "stone":
return StoneAxe("花岗岩斧头")
if type == "steel":
return SteelAxe("铁斧头")
'''
class Factory(object): def create_axe(self):
pass class Stone_Factory(Factory):
def create_axe(self):
return StoneAxe("花岗岩斧头") class Steel_Factory(Factory):
def create_axe(self):
return SteelAxe("铁斧头")
code来自https://blog.csdn.net/Mr_Quiet/article/details/80998337
#抽象工厂模式
#引入
纽约匹萨店生意火爆,越来越好,需要开好多家纽约披萨店,芝加哥也是面临同样的情况。为了保证质量,就得控制原料。所以我们得建造原料工厂,来生产不同区域的原料。
#定义
抽象工厂模式提供一个接口,用于创建相关或依赖对象的家族,而不需要明确指定具体类。
允许客户用抽象的借口创建一组产品,不需要知道实际产出的具体产品是什么,这样客户就从具体的产品解耦了。
#结构图
#使用场景
)客户端不依赖于产品类实例如何被创建、实现等细节
)强调一系列相关的产品对象(属于统一产品族)一起使用创建对象需要大量重复的代码
)提供一个产品类的库,所以的产品以同样或者大部分相同的接口出现,从而使客户端不依赖具体实现
#优点
实现解耦
#缺点
)规定了所有可能被创建的产品集合,产品族扩展新的产品困难,需要修改抽象工厂的接口
)增加了系统的抽象性和理解难度
#举个例子(java)
public interface Cheese { }
#############
public interface Pepperoni { }
##########
public interface Sauce { } ##################
public interface Clams { }
public class BlackOlives implements Veggies { } #########
public interface Dough { }
##########
public interface Veggies { } ######################################################################
public class MozzarellaCheese implements Cheese{ }
########
public class ReggianoCheese implements Cheese { }
##### public class Eggplant implements Veggies { }
#####
public class Garlic implements Veggies{ }
#######
public class Mushroom implements Veggies { }
###########
public class RedPepper implements Veggies{ }
########
public class Spinach implements Veggies{ }
#####
public class FreshClams implements Clams{ } ######
public class FrozenClams implements Clams{ } #######
public class MarinaraSauce implements Sauce { }
#########
public class PlumTomatoSauce implements Sauce {
}
########
public class SlicedPepperoni implements Pepperoni{ }
#########
public class SlicePepperoni implements Pepperoni{ }
########
public class ThinCrustDough implements Dough { }
########
public class ThickCrustDough implements Dough { }
########################################################
public interface PizzaIngredientFactory { public Sauce createSauce();
public Cheese createCheese();
public Veggies[] createVeggies();
public Pepperoni createPepperoni();
public Clams createClam();
public Dough createDough();
}
###################
public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
public Dough createDough(){
return new ThinCrustDough();
}
public Sauce createSauce(){
return new MarinaraSauce();
}
public Cheese createCheese(){
return new ReggianoCheese();
}
public Veggies[] createVeggies(){
Veggies veggies[]={new Garlic(),new Mushroom(),new RedPepper()};
return veggies;
}
public Pepperoni createPepperoni(){
return new SlicePepperoni();
}
public Clams createClam(){
return new FreshClams();
}
} ######### public class ChicagoPizzaIngredientFactory implements PizzaIngredientFactory {
public Dough createDough(){
return new ThickCrustDough();
}
public Sauce createSauce(){
return new PlumTomatoSauce();
}
public Cheese createCheese(){
return new MozzarellaCheese();
}
public Veggies[] createVeggies(){
Veggies veggies[]={new BlackOlives(),new Spinach(),new Eggplant()};
return veggies;
}
public Pepperoni createPepperoni(){
return new SlicedPepperoni();
}
public Clams createClam(){
return new FrozenClams();
}
} ####### ###############################################
public abstract class Pizza {
String name;
Dough dough;
Sauce sauce;
Veggies veggies[];
Cheese cheese;
Pepperoni pepperoni;
Clams clam; abstract void prepare(); void bake(){
System.out.print("Baking");
}; void cut(){
System.out.print("cut");
}; void box(){
System.out.print("box");
}; void setName(String name){
this.name=name;
} String getName(){
return name;
} public String toString(){
return name;
}
}
###############
public class CheesePizza extends Pizza{
PizzaIngredientFactory ingreditentFactory;
public CheesePizza(PizzaIngredientFactory ingredientFactory){
this.ingreditentFactory=ingredientFactory;
} void prepare(){
System.out.print("Preparing"+name);
dough=ingreditentFactory.createDough();
sauce=ingreditentFactory.createSauce();
cheese=ingreditentFactory.createCheese();
}
} #############
public class ClamPizza extends Pizza {
PizzaIngredientFactory ingredientFactory; public ClamPizza(PizzaIngredientFactory ingredientFactory){ this.ingredientFactory=ingredientFactory;
} void prepare(){
System.out.print("Preparing"+name);
dough=ingredientFactory.createDough();
sauce=ingredientFactory.createSauce();
clam=ingredientFactory.createClam();
}
} ######################
public class PepperoniPizza extends Pizza {
PizzaIngredientFactory ingreditentFactory;
public PepperoniPizza(PizzaIngredientFactory ingredientFactory){
this.ingreditentFactory=ingredientFactory;
} void prepare(){
System.out.print("Preparing"+name);
dough=ingreditentFactory.createDough();
sauce=ingreditentFactory.createSauce();
cheese=ingreditentFactory.createCheese();
}
}
################
public class VeggiePizza extends Pizza {
PizzaIngredientFactory ingreditentFactory;
public VeggiePizza(PizzaIngredientFactory ingredientFactory){
this.ingreditentFactory=ingredientFactory;
} void prepare(){
System.out.print("Preparing"+name);
dough=ingreditentFactory.createDough();
sauce=ingreditentFactory.createSauce();
cheese=ingreditentFactory.createCheese();
} }
###############################################################################################
public abstract class PizzaStore { public Pizza orderPizza(String type){
Pizza pizza;
pizza=createPizza(type); pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
abstract Pizza createPizza(String type); }
############################
public class NYPizzaStore extends PizzaStore{
protected Pizza createPizza(String item){
Pizza pizza=null;
PizzaIngredientFactory nyIngredientFactory=new NYPizzaIngredientFactory();
if(item.equals("cheese")){
pizza=new CheesePizza(nyIngredientFactory);
pizza.setName("New York Style Cheese Pizza");
}else if(item.equals("veggie")){
pizza=new VeggiePizza(nyIngredientFactory);
pizza.setName("New York Style Veggie Pizza");
}else if(item.equals("clam")){
pizza=new ClamPizza(nyIngredientFactory);
pizza.setName("New York Style Clam Pizza");
}else if(item.equals("pepperoni")){
pizza=new PepperoniPizza(nyIngredientFactory);
pizza.setName("New York Style Pepperoni Pizza");
}
return pizza;
}
}
###################
public class ChicagoPizzaStore extends PizzaStore{
protected Pizza createPizza(String item){
Pizza pizza=null;
PizzaIngredientFactory nyIngredientFactory=new ChicagoPizzaIngredientFactory();
if(item.equals("cheese")){
pizza=new CheesePizza(nyIngredientFactory);
pizza.setName("New York Style Cheese Pizza");
}else if(item.equals("veggie")){
pizza=new VeggiePizza(nyIngredientFactory);
pizza.setName("New York Style Veggie Pizza");
}else if(item.equals("clam")){
pizza=new ClamPizza(nyIngredientFactory);
pizza.setName("New York Style Clam Pizza");
}else if(item.equals("pepperoni")){
pizza=new PepperoniPizza(nyIngredientFactory);
pizza.setName("New York Style Pepperoni Pizza");
}
return pizza;
}
} ###########################################################################
public class javatest1 {
public static void main(String[] args) throws IOException,ClassNotFoundException{
PizzaStore nyPizzaStore=new NYPizzaStore();
nyPizzaStore.orderPizza("cheese");
System.out.print("\n");
PizzaStore chicagoPizzaStore=new ChicagoPizzaStore();
chicagoPizzaStore.orderPizza("clam");
}
}
#举个例子(python)
#!/usr/bin/env python
# -*- coding:utf-8 -*- __author__ = 'Andy'
"""
大话设计模式
设计模式——抽象工厂模式
抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们的类
"""
import sys #抽象用户表类
class User(object): def get_user(self):
pass def insert_user(self):
pass #抽象部门表类
class Department(object): def get_department(self):
pass def insert_department(self):
pass #操作具体User数据库类-Mysql
class MysqlUser(User): def get_user(self):
print 'MysqlUser get User' def insert_user(self):
print 'MysqlUser insert User' #操作具体Department数据库类-Mysql
class MysqlDepartment(Department): def get_department(self):
print 'MysqlDepartment get department' def insert_department(self):
print 'MysqlDepartment insert department' #操作具体User数据库-Orcal
class OrcaleUser(User): def get_user(self):
print 'OrcalUser get User' def insert_user(self):
print 'OrcalUser insert User' #操作具体Department数据库类-Orcal
class OrcaleDepartment(Department): def get_department(self):
print 'OrcalDepartment get department' def insert_department(self):
print 'OrcalDepartment insert department' #抽象工厂类
class AbstractFactory(object): def create_user(self):
pass def create_department(self):
pass class MysqlFactory(AbstractFactory): def create_user(self):
return MysqlUser() def create_department(self):
return MysqlDepartment() class OrcaleFactory(AbstractFactory): def create_user(self):
return OrcalUser() def create_department(self):
return OrcalDepartment() if __name__ == "__main__": db = sys.argv[1]
myfactory = ''
if db == 'Mysql':
myfactory = MysqlFactory()
elif db == 'Orcal':
myfactory = OrcaleFactory()
else:
print "不支持的数据库类型"
exit(0)
user = myfactory.create_user()
department = myfactory.create_department()
user.insert_user()
user.get_user()
department.insert_department()
department.get_department()
代码来自https://www.cnblogs.com/onepiece-andy/p/python-abstract-factory-pattern.html
#工厂方法模式与抽象工厂模式对比
)都是负责创建对象,工厂方法模式 用的方法是通过继承,抽象工厂模式 用的方法是对象的组合
)工厂方法模式 通过子类来创建对象,客户只需要知道所使用的抽象类型,右子类来负责决定具体类型。换句话说 工厂方法模式只负责将客户从具体类型中解耦。
)抽象工厂模式 用来创建一个产品家族的抽象类型,也可以把客户从所使用的具体产品中解耦。可以把一组相关的产品集合起来。
如果需要扩展这组相关产品,就必须改变接口,这是抽象工厂的缺点。工厂方法模式只涉及一个产品。
)抽象工厂模式经常使用工厂方法模式来实现它(抽象工厂模式)的具体工厂,纯粹是用来创建产品。
参考
《Head First设计模式》
https://blog.csdn.net/qq_28859325/article/details/60580578
https://www.jianshu.com/p/610a26d9d958