经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » Java相关 » 设计模式 » 查看文章
headfirst设计模式(5)—工厂模式体系分析及抽象工厂模式
来源:cnblogs  作者:纷飞丶  时间:2018/10/30 8:56:18  对本文有异议

先编一个这么久不写的理由

上周我终于鼓起勇气翻开了headfirst设计模式这本书,看看自己下一个设计模式要写个啥,然后,我终于知道我为啥这么久都没写设计模式了,headfirst的这个抽象工厂模式,额,我看了好几次,都不太理解。

在我的印象中,简单工厂,工厂方法,抽象工厂,这三个东西应该是层层递进的,然后我带着这个思路去看,emmmm,真的没看懂,还好最近又补了一遍《大话设计模式》,揣着刚刚温习了的新知识,然后又上了headfirst这条船,我感觉我这次应该是看懂了。

所以不写并不是因为忙,也不是因为懒,什么上分和吃鸡,我根本都没有听说过,和一个996的码农说这些,表示很扎心。

看完了工厂模式以后,发现后面居然是单例模式,兄弟,你是认真的吗?(泪流满面)

 

抽象工厂举例分析

首先,我去看了一下这本书配套的源代码,嗯,抽象工厂的类,感觉太多太多了,带上测试类一共是35个,这要是贴出来,可以水很大的篇幅了,但是我是那种人吗?当然不是!

碰到这种情况当然是直接给地址,有需要的小伙伴可以自己去看

github地址:https://github.com/bethrobson/Head-First-Design-Patterns

 

工厂模式递进体系分析

先捋一捋书中描述的抽象工厂是个什么意思,要说清楚这个,就必须先说一下它整个工厂模式的叙述的递进关系,具体如下:

1,先拿一个贼简单的创建Pizza的简单工厂类PizzaStore,来忽悠我,这章很简单,来学学吧,这章源代码只有8个类

2,兴冲冲的看完了第一部分,当然是一鼓作气的看第二部分,第二部分总结起来大概是讲这么一个事情:

  1)我们公司在纽约的那个旗舰店(PizzaStore)生意不错,现在我们要开一个分店,名字叫芝加哥披萨店(ChicagoPizzaStore)

  2)分店开了以后,原来的先进经验不能丢啊,所以PizzaStore被抽象出来了,搞成了一个抽象类,作为基础技术储备

  3)PizzaStore变成了公司的基础部门,专门指导披萨制作的流程

  4)旗舰店没办法啊,一方面自己的名字被占用了,一方面规范管理的风也吹来了,就改名字叫纽约披萨店(NYPizzaStore),旗下的所有披萨也顺势把名字也改了

  5)新开起来的芝加哥披萨店,倚靠了公司的技术实力,copy了一份旗舰店的菜单,但是也要照顾本地人的口味啊,所以就因地制宜,开发了自己的产品

  整个事情就是这样,涉及到的类有:pizza抽象类(1个),PizzaStore抽象类(1个),实体披萨店(2个),实体店的各类Pizza(8个),测试类(1个)

  总的来说,这一部分的递进关系很棒,也能很好的体现,简单工厂和工厂方法最大的不同,工厂方法可以对工厂类做到:开闭原则

3,工厂方法扯完了,就来看一下,抽象工厂嘛,这一波操作我当时着实没有看懂,就一直搁置了,为什么当时没看懂呢?

对于正常的抽象工厂的讲解套路来说应该是这个样子的:新增加一个产品线(抽象类,实现类),重新规划一下Factory的接口和实现类(Factory里新加一个接口,实现类新增实现)

它没有这样搞,它直接根据披萨原料,重新抽象了一套抽象工厂模式的体系出来,不得不说,这个比刚才说的那个新增产品线的例子漂亮太多了,原因有以下几点:

  1)直接新增一个产品线的这种操作,虽然更容易理解,但是会给人一个误导:我在原来Factory新增接口的这个操作,是符合设计模式,符合抽象工厂模式的

  2)抽象工厂的缺点是什么?缺点就是,Factory的接口,在实际使用的时候,几乎是无法新增产品的,修改太多了。所以它选择了使用原料这套新体系来讲解,更加符合实际

当然,它的例子也不是没有缺点,个人感觉它的缺点有以下几点:

  1)产生了类太多了,35个(上面有说过),对新手不友好,看到这个量级,稍微往后一翻又是一个单例模式,想着这个东西又不怎么能用上,有求生欲望的,都不会在放弃的边缘疯狂试探……

  2)对它本身的工厂方法模式的体系(PizzaStore体系),也有很大量的修改,集中体现在各类Pizza实现类的缩减(取消了按店铺名称来创建的各类披萨,转而使用了简单工厂模式里面的名字),Pizza的方法实现也有很多修改,主要是为了支持原料体系,当然,虽然产生了很多的修改,但是对外部提供的接口是没有影响的,换句话说,虽然实现有了翻天覆地的变化,但是顾客还是无感知的,这个从测试代码就能看出来:

工厂方法模式测试类:

  1. public class PizzaTestDrive {
  2. public static void main(String[] args) {
  3. PizzaStore nyStore = new NYPizzaStore();
  4. PizzaStore chicagoStore = new ChicagoPizzaStore();
  5. Pizza pizza = nyStore.orderPizza("cheese");
  6. System.out.println("Ethan ordered a " + pizza.getName() + "\n");
  7. pizza = chicagoStore.orderPizza("cheese");
  8. System.out.println("Joel ordered a " + pizza.getName() + "\n");
  9. pizza = nyStore.orderPizza("clam");
  10. System.out.println("Ethan ordered a " + pizza.getName() + "\n");
  11. pizza = chicagoStore.orderPizza("clam");
  12. System.out.println("Joel ordered a " + pizza.getName() + "\n");
  13. pizza = nyStore.orderPizza("pepperoni");
  14. System.out.println("Ethan ordered a " + pizza.getName() + "\n");
  15. pizza = chicagoStore.orderPizza("pepperoni");
  16. System.out.println("Joel ordered a " + pizza.getName() + "\n");
  17. pizza = nyStore.orderPizza("veggie");
  18. System.out.println("Ethan ordered a " + pizza.getName() + "\n");
  19. pizza = chicagoStore.orderPizza("veggie");
  20. System.out.println("Joel ordered a " + pizza.getName() + "\n");
  21. }
  22. }
View Code

抽象工厂测试类:

  1. public class PizzaTestDrive {
  2. public static void main(String[] args) {
  3. PizzaStore nyStore = new NYPizzaStore();
  4. PizzaStore chicagoStore = new ChicagoPizzaStore();
  5. Pizza pizza = nyStore.orderPizza("cheese");
  6. System.out.println("Ethan ordered a " + pizza + "\n");
  7. pizza = chicagoStore.orderPizza("cheese");
  8. System.out.println("Joel ordered a " + pizza + "\n");
  9. pizza = nyStore.orderPizza("clam");
  10. System.out.println("Ethan ordered a " + pizza + "\n");
  11. pizza = chicagoStore.orderPizza("clam");
  12. System.out.println("Joel ordered a " + pizza + "\n");
  13. pizza = nyStore.orderPizza("pepperoni");
  14. System.out.println("Ethan ordered a " + pizza + "\n");
  15. pizza = chicagoStore.orderPizza("pepperoni");
  16. System.out.println("Joel ordered a " + pizza + "\n");
  17. pizza = nyStore.orderPizza("veggie");
  18. System.out.println("Ethan ordered a " + pizza + "\n");
  19. pizza = chicagoStore.orderPizza("veggie");
  20. System.out.println("Joel ordered a " + pizza + "\n");
  21. }
  22. }
View Code

是一个非常赞的地方

 

抽象工厂实现过程

首先,我们从原料的工厂类入手:

  1. public interface PizzaIngredientFactory {
  2. Dough createDough();
  3. Sauce createSauce();
  4. Cheese createCheese();
  5. Veggies[] createVeggies();
  6. Pepperoni createPepperoni();
  7. Clams createClam();
  8. }

一共有6种原料可以创建,这个也是它源代码类多的原因之一,由于大多数代码都是相似的,所以这里也就不一一的列举了只列举流程相关的实现

先看酱油(Sauce)相关的接口和实现:

  1. public interface Sauce {
  2. String toString();
  3. }

PlumTomatoSauce:

  1. public class PlumTomatoSauce implements Sauce {
  2. public String toString() {
  3. return "Tomato sauce with plum tomatoes";
  4. }
  5. }
View Code

MarinaraSauce:

  1. public class MarinaraSauce implements Sauce {
  2. public String toString() {
  3. return "Marinara Sauce";
  4. }
  5. }
View Code

然后看看面团的相关接口和实现:

  1. public interface Dough {
  2. String toString();
  3. }

ThickCrustDough:

  1. public class ThickCrustDough implements Dough {
  2. public String toString() {
  3. return "ThickCrust style extra thick crust dough";
  4. }
  5. }
View Code

ThinCrustDough:

  1. public class ThinCrustDough implements Dough {
  2. public String toString() {
  3. return "Thin Crust Dough";
  4. }
  5. }
View Code

以上,是抽象工厂的基础:产品族的工厂类,产品接口(或者是抽象类),产品的具体实现类请忽略它只是为了方便理解放到一起的

列举了这个,再来看看具体的原料工厂:

ChicagoPizzaIngredientFactory:

  1. public class ChicagoPizzaIngredientFactory
  2. implements PizzaIngredientFactory
  3. {
  4. //我是面团,我是这里
  5. public Dough createDough() {
  6. return new ThickCrustDough();
  7. }
  8. //我是酱油,我在这里
  9. public Sauce createSauce() {
  10. return new PlumTomatoSauce();
  11. }
  12. public Cheese createCheese() {
  13. return new MozzarellaCheese();
  14. }
  15. public Veggies[] createVeggies() {
  16. Veggies veggies[] = { new BlackOlives(),
  17. new Spinach(),
  18. new Eggplant() };
  19. return veggies;
  20. }
  21. public Pepperoni createPepperoni() {
  22. return new SlicedPepperoni();
  23. }
  24. public Clams createClam() {
  25. return new FrozenClams();
  26. }
  27. }
View Code

NYPizzaIngredientFactory:

  1. public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
  2. //我是面团,我在这里
  3. public Dough createDough() {
  4. return new ThinCrustDough();
  5. }
  6. //我是酱油,我在这里
  7. public Sauce createSauce() {
  8. return new MarinaraSauce();
  9. }
  10. public Cheese createCheese() {
  11. return new ReggianoCheese();
  12. }
  13. public Veggies[] createVeggies() {
  14. Veggies veggies[] = { new Garlic(), new Onion(), new Mushroom(), new RedPepper() };
  15. return veggies;
  16. }
  17. public Pepperoni createPepperoni() {
  18. return new SlicedPepperoni();
  19. }
  20. public Clams createClam() {
  21. return new FreshClams();
  22. }
  23. }
View Code

实现也是很简单的,这里为了不占篇幅就隐藏了,有需要的自己点开看,接下来看一个这个原料体系的建立,需要修改的体现:

1,各类Pizza的实现类,需要持有PizzaIngredientFactory对象,并且prepare方法会有修改

  1. public class ClamPizza extends Pizza {
  2. PizzaIngredientFactory ingredientFactory;
  3. public ClamPizza(PizzaIngredientFactory ingredientFactory) {
  4. this.ingredientFactory = ingredientFactory;
  5. }
  6. void prepare() {
  7. System.out.println("Preparing " + name);
  8. dough = ingredientFactory.createDough();
  9. sauce = ingredientFactory.createSauce();
  10. cheese = ingredientFactory.createCheese();
  11. clam = ingredientFactory.createClam();
  12. }
  13. }

2,具体的pizza工厂的修改:

  1. public class ChicagoPizzaStore extends PizzaStore {
  2. protected Pizza createPizza(String item) {
  3. Pizza pizza = null;
  4. //创建各自的原料工厂
  5. PizzaIngredientFactory ingredientFactory =
  6. new ChicagoPizzaIngredientFactory();
  7. if (item.equals("cheese")) {
  8. //创建具体pizza的时候传入原料工厂
  9. pizza = new CheesePizza(ingredientFactory);
  10. pizza.setName("Chicago Style Cheese Pizza");
  11. } else if (item.equals("veggie")) {
  12. pizza = new VeggiePizza(ingredientFactory);
  13. pizza.setName("Chicago Style Veggie Pizza");
  14. } else if (item.equals("clam")) {
  15. pizza = new ClamPizza(ingredientFactory);
  16. pizza.setName("Chicago Style Clam Pizza");
  17. } else if (item.equals("pepperoni")) {
  18. pizza = new PepperoniPizza(ingredientFactory);
  19. pizza.setName("Chicago Style Pepperoni Pizza");
  20. }
  21. return pizza;
  22. }
  23. }

以上就是抽象工厂类的实现套路,以及在head first中,对原工厂方法模式具体影响的叙述,贴代码是不可能贴代码的,这辈子都不可能贴代码的

 

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号