HeadFirst设计模式读书笔记之工厂模式

1. 简单工厂

1. 你开了一家披萨店,点披萨的方法可能是这样:

    public Pizza orderPizza(String type) {
Pizza pizza;
if (type.equals("芒果披萨")){
pizza = new MangoPizza();
}else if (type.equals("核桃披萨")){
pizza = new WalnutPizza();
}else if (type.equals("橙皮披萨")){
pizza = new FlavedoPizza();
}else {
pizza = new StarPizza();
} pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}

可以看到,每当你想增加一种披萨类型,就要修改代码,添加一种if else条件.当有多个系统存在orderPizza的需求时,每个系统都要同时修改他们的代码.因此,需要将这种实例化具体对象的代码封装起来.

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("芒果披萨")){
pizza = new MangoPizza();
}else if (type.equals("核桃披萨")){
pizza = new WalnutPizza();
}else if (type.equals("橙皮披萨")){
pizza = new FlavedoPizza();
}else {
pizza = new StarPizza();
} return pizza;
}
}

这就是简单工厂方法,他不算一种设计模式,而是一种编程习惯.其要点有二:

1. 将产品定义为抽象类,可以被覆盖

2. 将具体的产品放到工厂类中来实例化,由工厂创建并返回给客户,这样便使得产品的创建逻辑可以解耦合,并增加了复用性

2. 工厂方法

1. 假设你现在有了很多加盟店,每种加盟店根据地区的差异有自己的工厂,但加盟店虽然采用工厂方法创建披萨,但其他部分却有所不同:烘烤的做法,不切片,使用杂七杂八的盒子...

这时,你想把创建披萨的方法与每家披萨店绑定在一起,让每家PizzaStore中都使用createPizza()创建pizza,并且这些店还可以拥有一定的制作披萨的自主权.因此,我们需要把PizzaStore和createPizza()定义成抽象的

/**
* 抽象的PizzaStore
*/
public abstract class PizzaStore { public Pizza orderPizza(String type) {
Pizza pizza;
// 使用自己的方法做披萨
pizza = createPizza(type); pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
} // 将做披萨的工厂方法放到PizzaStore中,工厂方法是抽象的,所以依赖子类来处理对象的创建
public abstract Pizza createPizza(String type);
}

2. 现在由PizzaStore的子类来具体卖披萨

public class BeijingPizzaStore extends PizzaStore {
@Override
public Pizza createPizza(String item) {
if (item.equals("橙皮披萨")){
return new FlavedoPizza();
}else {
return new PekingDuckPizza();
}
}
}
public class ChengduPizza extends PizzaStore {
@Override
public Pizza createPizza(String type) {
if (type.equals("芒果披萨")){
return new MangoPizza();
}else {
return new StarPizza();
}
}
}

现在,orderPizza()与具体的Pizza实现了一定的解耦合,决定最终Pizza对象的变成了某个具体的pizza店,而pizza店则由顾客来决定

3. 一些对工厂方法的理解:

1. 工厂方法是抽象的,所以依赖子类来创建对象,这样便将超类的代码与具体创建产品的代码分割开了

2. 工厂方法必须返回一个产品,超类通常中会用到这个产品

3. 工厂方法将产品与创建者抽象为接口,使他们成为平级的存在,具体的产品创建则使用子类来交互

4. 工厂方法将产品实例化的操作推迟到子类,子类的选择则由创建者来决定

5. 简单工厂方法更趋向组合,工厂方法则利用抽象和继承

6. 简单工厂封装了对象的创建,一个工厂处理所有的产品,但对同一个产品不可变更其做法,工厂方法则更有弹性,子类通过重写可以更改产品的创建

3. 依赖倒置原则

下面是一个简单粗暴的披萨店:

/**
* 依赖具体对象的PizzaStore
*/
public class PizzaStore { public Pizza createPizza(String style, String type){
Pizza pizza = null;
if (style.equals("一元档")){
if (type.equals("芒果披萨")){
pizza = new MangoPizza();
}else if (type.equals("核桃披萨")){
pizza = new WalnutPizza();
}
}else if (style.equals("二元档")){
if (type.equals("北京烤鸭披萨")){
pizza = new PekingDuckPizza();
}else if (type.equals("橙皮披萨")){
pizza = new FlavedoPizza();
}
}else {
System.out.println("披萨卖完了");
} pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
}

可以看到,这个披萨店依赖于每一个具体的披萨对象,每增加一个披萨就要修改一次代码,增加一个依赖,可以说是非常不好用了

HeadFirst设计模式读书笔记之工厂模式

从图中看到,高层组件直接依赖于低层组件而依赖倒置原则的的内容就是:

要依赖抽象,不要依赖具体类

这个原则说明不管高层还是低层组件都不应该依赖具体类,而应该依赖于抽象.如图所示:

HeadFirst设计模式读书笔记之工厂模式

与之前相比高层组件PizzaStore不在直接依赖于具体的Pizza对象,而是依赖于Pizza接口,而具体的Pizza产品则由被高层组件依赖颠倒成了依赖Pizza接口,这就是一种依赖倒置.总体来看,PizzaStore和Pizza都抽象化了,不用再依赖于具体的类型,符合依赖倒置的设计原则.

有三个指导方针可以让你更好地遵守依赖倒置原则:

  • 变量不可以持有具体类的引用
  • 不要让类派生自具体类
  • 不要覆盖基类中已覆盖的方法

4. 抽象工厂方法:创建产品家族

与普通的工厂方法比较,抽象工厂方法要显得重型得多: 工厂方法只创建一种产品,抽象工厂方法则创建一个家族的产品

1. 典型做法是创建一个工厂的接口,这个接口负责创建所有的产品家族成员,如创建一个生产调料家族的工厂:

/**
* 原料工厂的接口,实现这样的接口,可以随意组合产出各式各样的调料
* 每个原料都是一个类
*/
public interface SeasoningFactory { Chili createChili(); DouBan createDouBan(); Pepper createPepper(); Salt createSalt(); }
/**
* 郫县调料生产厂
*/
public class PiXianSeasoningFactory implements SeasoningFactory { /**
* 虎皮青椒
* @return
*/
@Override
public Chili createChili() {
return new HuPiQingJiao();
} /**
* 郫县豆瓣
* @return
*/
@Override
public DouBan createDouBan() {
return new PiXianDouBan();
} /**
* 花椒油
* @return
*/
@Override
public Pepper createPepper() {
return new HuaJiaoYou();
} /**
* 食用盐
* @return
*/
@Override
public Salt createSalt() {
return new ShiYongYan();
}
}
/**
* 灌县调料生产厂
*/
public class GuanXianSeasoningFactory implements SeasoningFactory { /**
* 虎皮青椒
* @return
*/
@Override
public Chili createChili() {
return new HuPiQingJiao();
} /**
* 老干妈豆瓣酱
* @return
*/
@Override
public DouBan createDouBan() {
return new LaoGanMaDouBanJiang();
} /**
* 花椒油
* @return
*/
@Override
public Pepper createPepper() {
return new HuaJiaoYou();
} /**
* 食用盐
* @return
*/
@Override
public Salt createSalt() {
return new ShiYongYan();
}
}

下面是抽象工厂方法的类图:

HeadFirst设计模式读书笔记之工厂模式

从类图中可以看出来,抽象工厂方法有一个缺点,就是当添加了一个新产品接口时,要去抽象工厂接口中添加一个方法,这会造成一些麻烦

2. 工厂方法与抽象工厂的一些对比

相同点:

  • 都是负责创建对象
  • 都能使程序解耦,将程序从创建大量具体对象的泥潭中拉出来

不同点:

  • 工厂方法用子类来创建具体对象,利用抽象和继承.抽象工厂包含了一大堆接口,利用组合的思想来创建对象
  • 工厂方法一般用来创建一种产品,抽象工厂则创建一族产品
  • 工厂方法功能简单,使用轻便.抽象工厂功能强大,使用时会创建大量的类

3. 下面使用抽象工厂生产的原料来制作披萨

/**
* 原料工厂的接口,实现这样的接口,可以随意组合产出各式各样的调料
* 每个原料都是一个类
*/
public interface SeasoningFactory { /**
* 辣椒
* @return
*/
Chili createChili(); /**
* 豆瓣
* @return
*/
DouBan createDouBan(); /**
* 花椒
* @return
*/
Pepper createPepper(); /**
* 盐
* @return
*/
Salt createSalt(); }
/**
* 豆瓣
*/
public abstract class DouBan {
public abstract String sayMyName();
}
public class PiXianDouBan extends DouBan {
@Override
public String sayMyName() {
return "郫县豆瓣";
}
}
public class LaoGanMaDouBanJiang extends DouBan {
@Override
public String sayMyName() {
return "老干妈豆瓣酱";
}
}
/**
* 郫县调料生产厂
*/
public class PiXianSeasoningFactory implements SeasoningFactory { /**
* 虎皮青椒
* @return
*/
@Override
public Chili createChili() {
return new HuPiQingJiao();
} /**
* 郫县豆瓣
* @return
*/
@Override
public DouBan createDouBan() {
return new PiXianDouBan();
} /**
* 花椒油
* @return
*/
@Override
public Pepper createPepper() {
return new HuaJiaoYou();
} /**
* 食用盐
* @return
*/
@Override
public Salt createSalt() {
return new ShiYongYan();
}
}
/**
* 灌县调料生产厂
*/
public class GuanXianSeasoningFactory implements SeasoningFactory { /**
* 虎皮青椒
* @return
*/
@Override
public Chili createChili() {
return new HuPiQingJiao();
} /**
* 老干妈豆瓣酱
* @return
*/
@Override
public DouBan createDouBan() {
return new LaoGanMaDouBanJiang();
} /**
* 花椒油
* @return
*/
@Override
public Pepper createPepper() {
return new HuaJiaoYou();
} /**
* 食用盐
* @return
*/
@Override
public Salt createSalt() {
return new ShiYongYan();
}
}
/**
* 每一个披萨都有一组抽象工厂生产的原料
*
*/
public abstract class Pizza { protected String name; /**
* 辣椒
*/
protected Chili chili; /**
* 豆瓣
*/
protected DouBan douBan; /**
* 花椒
*/
protected Pepper pepper; /**
* 盐
*/
protected Salt salt; /**
* 在这个方法中,收集抽象工厂生产的原料
*/
public abstract void prepare(); public void bake(){
System.out.println("烘烤...");
} public void cut(){
System.out.println("切片...");
} public void box() {
System.out.println("包装...");
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} @Override
public String toString(){
return "披萨制作完毕:"+name
+"\n生产原料:"+chili.sayMyName()
+"\t"+douBan.sayMyName()
+"\t"+pepper.sayMyName()
+"\t"+salt.sayMyName(); }
}
public class ChengduPizza extends Pizza{

    // 调料工厂
SeasoningFactory seasoningFactory; public ChengduPizza(SeasoningFactory seasoningFactory) {
this.name = "旧成都披萨";
this.seasoningFactory = seasoningFactory;
} @Override
public void prepare() {
System.out.println("开始准备 "+getName()+":");
chili = seasoningFactory.createChili();
douBan = seasoningFactory.createDouBan();
pepper = seasoningFactory.createPepper();
salt = seasoningFactory.createSalt();
System.out.println("以下原料准备完毕:"+chili.sayMyName()
+","+douBan.sayMyName()+","+pepper.sayMyName()+","+salt.sayMyName());
}
}
public abstract class PizzaStore {

    public abstract Pizza createPizza(String type);
}
public class StarBoundPizzaStore extends PizzaStore {
@Override
public Pizza createPizza(String type) {
Pizza pizza;
SeasoningFactory factoryA = new PiXianSeasoningFactory();
SeasoningFactory factoryB = new GuanXianSeasoningFactory(); if (type.equals("旧成都披萨")){
pizza = new ChengduPizza(factoryA);;
}else if (type.equals("新北京披萨")){
pizza = new PekingPizza(factoryB);
}else {
pizza = new ChengduPizza(factoryB);
}
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box(); return pizza;
} public static void main(String[] args) {
PizzaStore pizzaStore = new StarBoundPizzaStore();
Pizza pizza = pizzaStore.createPizza("旧成都披萨");
System.out.println(pizza.toString());
Pizza pizza1 = pizzaStore.createPizza("新北京披萨");
System.out.println(pizza1.toString());
}
}
结果:
开始准备 旧成都披萨:
以下原料准备完毕:虎皮青椒,郫县豆瓣,花椒油,食用盐
烘烤...
切片...
包装...
披萨制作完毕:旧成都披萨
生产原料:虎皮青椒 郫县豆瓣 花椒油 食用盐
开始准备 新北京披萨:
以下原料准备完毕:虎皮青椒,老干妈豆瓣酱,花椒油,食用盐
烘烤...
切片...
包装...
披萨制作完毕:新北京披萨
生产原料:虎皮青椒 老干妈豆瓣酱 花椒油 食用盐
上一篇:[OpenCV] IplImage and Functions


下一篇:Video标签播放视频?谷歌浏览器?safari?? 谷歌浏览器播放不了mp4格式的视频的原因