经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » 设计模式 » 查看文章
HeadFirst设计模式读书笔记之工厂模式
来源：cnblogs　　作者：被杜撰的风　　时间：2018/11/29 9:23:39　　对本文有异议

1. 简单工厂

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

  1.     public Pizza orderPizza(String type) {
  2.         Pizza pizza;
  3.         if (type.equals("芒果披萨")){
  4.             pizza = new MangoPizza();
  5.         }else if (type.equals("核桃披萨")){
  6.             pizza = new WalnutPizza();
  7.         }else if (type.equals("橙皮披萨")){
  8.             pizza = new FlavedoPizza();
  9.         }else {
  10.             pizza = new StarPizza();
  11.         }
  13.         pizza.prepare();
  14.         pizza.bake();
  15.         pizza.cut();
  16.         pizza.box();
  17.         return pizza;
  18.     }

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

  1. public class PizzaStore {
  3.     SimplePizzaFactory factory;
  5.     public PizzaStore(SimplePizzaFactory factory){
  6.         this.factory = factory;
  7.     }
  9.     public Pizza orderPizza(String type) {
  10.         Pizza pizza;
  11.         pizza = factory.createPizza(type);
  13.         pizza.prepare();
  14.         pizza.bake();
  15.         pizza.cut();
  16.         pizza.box();
  17.         return pizza;
  18.     }
  19. }
  1. public class SimplePizzaFactory {
  3.     public Pizza createPizza(String type){
  4.         Pizza pizza = null;
  5.         
  6.         if (type.equals("芒果披萨")){
  7.             pizza = new MangoPizza();
  8.         }else if (type.equals("核桃披萨")){
  9.             pizza = new WalnutPizza();
  10.         }else if (type.equals("橙皮披萨")){
  11.             pizza = new FlavedoPizza();
  12.         }else {
  13.             pizza = new StarPizza();
  14.         }
  15.         
  16.         return pizza;
  17.     }
  18. }

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

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

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

2. 工厂方法

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

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

  1. /**
  2.  * 抽象的PizzaStore
  3.  */
  4. public abstract class PizzaStore {
  6.     public Pizza orderPizza(String type) {
  7.         Pizza pizza;
  8.         // 使用自己的方法做披萨
  9.         pizza = createPizza(type);
  11.         pizza.prepare();
  12.         pizza.bake();
  13.         pizza.cut();
  14.         pizza.box();
  15.         return pizza;
  16.     }
  18.     // 将做披萨的工厂方法放到PizzaStore中,工厂方法是抽象的,所以依赖子类来处理对象的创建
  19.     public abstract Pizza createPizza(String type);
  20. }

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

  1. public class BeijingPizzaStore extends PizzaStore {
  2.     @Override
  3.     public Pizza createPizza(String item) {
  4.         if (item.equals("橙皮披萨")){
  5.             return new FlavedoPizza();
  6.         }else {
  7.             return new PekingDuckPizza();
  8.         }
  9.     }
  10. }
  1. public class ChengduPizza extends PizzaStore {
  2.     @Override
  3.     public Pizza createPizza(String type) {
  4.         if (type.equals("芒果披萨")){
  5.             return new MangoPizza();
  6.         }else {
  7.             return new StarPizza();
  8.         }
  9.     }
  10. }

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

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

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

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

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

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

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

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

3. 依赖倒置原则

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

  1. /**
  2.  * 依赖具体对象的PizzaStore
  3.  */
  4. public class PizzaStore {
  5.     
  6.     public Pizza createPizza(String style, String type){
  7.         Pizza pizza = null;
  8.         if (style.equals("一元档")){
  9.             if (type.equals("芒果披萨")){
  10.                 pizza = new MangoPizza();
  11.             }else if (type.equals("核桃披萨")){
  12.                 pizza = new WalnutPizza();
  13.             }
  14.         }else if (style.equals("二元档")){
  15.             if (type.equals("北京烤鸭披萨")){
  16.                 pizza = new PekingDuckPizza();
  17.             }else if (type.equals("橙皮披萨")){
  18.                 pizza = new FlavedoPizza();
  19.             }
  20.         }else {
  21.             System.out.println("披萨卖完了");
  22.         }
  23.         
  24.         pizza.prepare();
  25.         pizza.bake();
  26.         pizza.cut();
  27.         pizza.box();
  28.         return pizza;
  29.     }
  30. }

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

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

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

与之前相比高层组件PizzaStore不在直接依赖于具体的Pizza对象,而是依赖于Pizza接口,而具体的Pizza产品则由被高层组件依赖颠倒成了依赖Pizza接口,这就是一种依赖倒置.总体来看,PizzaStore和Pizza都抽象化了,不用再依赖于具体的类型,符合依赖倒置的设计原则.
有三个指导方针可以让你更好地遵守依赖倒置原则:

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

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

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

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

  1. /**
  2. * 原料工厂的接口,实现这样的接口,可以随意组合产出各式各样的调料
  3. * 每个原料都是一个类
  4. */
  5. public interface SeasoningFactory {
  7.    Chili createChili();
  8.    
  9.    DouBan createDouBan();
  10.    
  11.    Pepper createPepper();
  12.    
  13.    Salt createSalt();
  15. }
  1. /**
  2.  * 郫县调料生产厂
  3.  */
  4. public class PiXianSeasoningFactory implements SeasoningFactory {
  6.     /**
  7.      *  虎皮青椒
  8.      * @return
  9.      */
  10.     @Override
  11.     public Chili createChili() {
  12.         return new HuPiQingJiao();
  13.     }
  15.     /**
  16.      * 郫县豆瓣
  17.      * @return
  18.      */
  19.     @Override
  20.     public DouBan createDouBan() {
  21.         return new PiXianDouBan();
  22.     }
  24.     /**
  25.      * 花椒油
  26.      * @return
  27.      */
  28.     @Override
  29.     public Pepper createPepper() {
  30.         return new HuaJiaoYou();
  31.     }
  33.     /**
  34.      * 食用盐
  35.      * @return
  36.      */
  37.     @Override
  38.     public Salt createSalt() {
  39.         return new ShiYongYan();
  40.     }
  41. }
  1. /**
  2.  * 灌县调料生产厂
  3.  */
  4. public class GuanXianSeasoningFactory implements SeasoningFactory {
  6.     /**
  7.      *  虎皮青椒
  8.      * @return
  9.      */
  10.     @Override
  11.     public Chili createChili() {
  12.         return new HuPiQingJiao();
  13.     }
  15.     /**
  16.      * 老干妈豆瓣酱
  17.      * @return
  18.      */
  19.     @Override
  20.     public DouBan createDouBan() {
  21.         return new LaoGanMaDouBanJiang();
  22.     }
  24.     /**
  25.      * 花椒油
  26.      * @return
  27.      */
  28.     @Override
  29.     public Pepper createPepper() {
  30.         return new HuaJiaoYou();
  31.     }
  33.     /**
  34.      * 食用盐
  35.      * @return
  36.      */
  37.     @Override
  38.     public Salt createSalt() {
  39.         return new ShiYongYan();
  40.     }
  41. }

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

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

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

相同点:

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

不同点:

  • 工厂方法用子类来创建具体对象,利用抽象和继承.抽象工厂包含了一大堆接口,利用组合的思想来创建对象
  • 工厂方法一般用来创建一种产品,抽象工厂则创建一族产品

  • 工厂方法功能简单,使用轻便.抽象工厂功能强大,使用时会创建大量的类

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

  1. /**
  2.  * 原料工厂的接口,实现这样的接口,可以随意组合产出各式各样的调料
  3.  * 每个原料都是一个类
  4.  */
  5. public interface SeasoningFactory {
  7.     /**
  8.      * 辣椒
  9.      * @return
  10.      */
  11.     Chili createChili();
  13.     /**
  14.      * 豆瓣
  15.      * @return
  16.      */
  17.     DouBan createDouBan();
  19.     /**
  20.      * 花椒
  21.      * @return
  22.      */
  23.     Pepper createPepper();
  25.     /**
  26.      * 盐
  27.      * @return
  28.      */
  29.     Salt createSalt();
  31. }
  1. /**
  2.  * 豆瓣
  3.  */
  4. public abstract class DouBan {
  5.     public abstract String sayMyName();
  6. }
  1. public class PiXianDouBan extends DouBan {
  2.     @Override
  3.     public String sayMyName() {
  4.         return "郫县豆瓣";
  5.     }
  6. }
  1. public class LaoGanMaDouBanJiang extends DouBan {
  2.     @Override
  3.     public String sayMyName() {
  4.         return "老干妈豆瓣酱";
  5.     }
  6. }
  1. /**
  2.  * 郫县调料生产厂
  3.  */
  4. public class PiXianSeasoningFactory implements SeasoningFactory {
  6.     /**
  7.      *  虎皮青椒
  8.      * @return
  9.      */
  10.     @Override
  11.     public Chili createChili() {
  12.         return new HuPiQingJiao();
  13.     }
  15.     /**
  16.      * 郫县豆瓣
  17.      * @return
  18.      */
  19.     @Override
  20.     public DouBan createDouBan() {
  21.         return new PiXianDouBan();
  22.     }
  24.     /**
  25.      * 花椒油
  26.      * @return
  27.      */
  28.     @Override
  29.     public Pepper createPepper() {
  30.         return new HuaJiaoYou();
  31.     }
  33.     /**
  34.      * 食用盐
  35.      * @return
  36.      */
  37.     @Override
  38.     public Salt createSalt() {
  39.         return new ShiYongYan();
  40.     }
  41. }
  1. /**
  2.  * 灌县调料生产厂
  3.  */
  4. public class GuanXianSeasoningFactory implements SeasoningFactory {
  6.     /**
  7.      *  虎皮青椒
  8.      * @return
  9.      */
  10.     @Override
  11.     public Chili createChili() {
  12.         return new HuPiQingJiao();
  13.     }
  15.     /**
  16.      * 老干妈豆瓣酱
  17.      * @return
  18.      */
  19.     @Override
  20.     public DouBan createDouBan() {
  21.         return new LaoGanMaDouBanJiang();
  22.     }
  24.     /**
  25.      * 花椒油
  26.      * @return
  27.      */
  28.     @Override
  29.     public Pepper createPepper() {
  30.         return new HuaJiaoYou();
  31.     }
  33.     /**
  34.      * 食用盐
  35.      * @return
  36.      */
  37.     @Override
  38.     public Salt createSalt() {
  39.         return new ShiYongYan();
  40.     }
  41. }
  1. /**
  2.  * 每一个披萨都有一组抽象工厂生产的原料
  3.  *
  4.  */
  5. public abstract class Pizza {
  7.     protected String name;
  9.     /**
  10.      * 辣椒
  11.      */
  12.     protected Chili chili;
  14.     /**
  15.      * 豆瓣
  16.      */
  17.     protected DouBan douBan;
  19.     /**
  20.      * 花椒
  21.      */
  22.     protected Pepper pepper;
  24.     /**
  25.      * 盐
  26.      */
  27.     protected Salt salt;
  30.     /**
  31.      * 在这个方法中,收集抽象工厂生产的原料
  32.      */
  33.     public abstract void prepare();
  35.     public void bake(){
  36.         System.out.println("烘烤...");
  37.     }
  39.     public void cut(){
  40.         System.out.println("切片...");
  41.     }
  43.     public void box() {
  44.         System.out.println("包装...");
  45.     }
  47.     public String getName() {
  48.         return name;
  49.     }
  51.     public void setName(String name) {
  52.         this.name = name;
  53.     }
  55.     @Override
  56.     public String toString(){
  57.          return "披萨制作完毕:"+name
  58.         +"\n生产原料:"+chili.sayMyName()
  59.                 +"\t"+douBan.sayMyName()
  60.                 +"\t"+pepper.sayMyName()
  61.                 +"\t"+salt.sayMyName();
  63.     }
  64. }
  1. public class ChengduPizza extends Pizza{
  3.     // 调料工厂
  4.     SeasoningFactory seasoningFactory;
  6.     public ChengduPizza(SeasoningFactory seasoningFactory) {
  7.         this.name = "旧成都披萨";
  8.         this.seasoningFactory = seasoningFactory;
  9.     }
  11.     @Override
  12.     public void prepare() {
  13.         System.out.println("开始准备 "+getName()+":");
  14.         chili = seasoningFactory.createChili();
  15.         douBan = seasoningFactory.createDouBan();
  16.         pepper = seasoningFactory.createPepper();
  17.         salt = seasoningFactory.createSalt();
  18.         System.out.println("以下原料准备完毕:"+chili.sayMyName()
  19.         +","+douBan.sayMyName()+","+pepper.sayMyName()+","+salt.sayMyName());
  20.     }
  21. }
  1. public abstract class PizzaStore {
  3.     public abstract Pizza createPizza(String type);
  4. }
  1. public class StarBoundPizzaStore extends PizzaStore {
  2.     @Override
  3.     public Pizza createPizza(String type) {
  4.         Pizza pizza;
  5.         SeasoningFactory factoryA = new PiXianSeasoningFactory();
  6.         SeasoningFactory factoryB = new GuanXianSeasoningFactory();
  8.         if (type.equals("旧成都披萨")){
  9.             pizza = new ChengduPizza(factoryA);;
  10.         }else if (type.equals("新北京披萨")){
  11.             pizza = new PekingPizza(factoryB);
  12.         }else {
  13.             pizza = new ChengduPizza(factoryB);
  14.         }
  15.         pizza.prepare();
  16.         pizza.bake();
  17.         pizza.cut();
  18.         pizza.box();
  20.         return pizza;
  21.     }
  23.     public static void main(String[] args) {
  24.         PizzaStore pizzaStore = new StarBoundPizzaStore();
  25.         Pizza pizza = pizzaStore.createPizza("旧成都披萨");
  26.         System.out.println(pizza.toString());
  27.         Pizza pizza1 = pizzaStore.createPizza("新北京披萨");
  28.         System.out.println(pizza1.toString());
  29.     }
  30. }
  1. 结果:
  2. 开始准备 旧成都披萨:
  3. 以下原料准备完毕:虎皮青椒,郫县豆瓣,花椒油,食用盐
  4. 烘烤...
  5. 切片...
  6. 包装...
  7. 披萨制作完毕:旧成都披萨
  8. 生产原料:虎皮青椒   郫县豆瓣    花椒油 食用盐
  9. 开始准备 新北京披萨:
  10. 以下原料准备完毕:虎皮青椒,老干妈豆瓣酱,花椒油,食用盐
  11. 烘烤...
  12. 切片...
  13. 包装...
  14. 披萨制作完毕:新北京披萨
  15. 生产原料:虎皮青椒   老干妈豆瓣酱  花椒油 食用盐
 友情链接：直通硅谷 　点职佳 　北美留学生论坛

设计模式热门文章

  • java设计模式-装饰者模式详解
  • 设计模式之迭代器与组合模式（四）
  • asp.net Core 中AuthorizationHandler 实现自定义授权
  • 高校宿舍管理系统详细需求分析说明书
  • 依赖注入与控制反转
  • 设计模式-工厂方法模式 实战演习 代码实现 - Code-CHAN
  • 报刊订阅管理系统的设计与实现
  • 深入浅出设计模式 PDF下载高清完整扫描原版
  • TypeScript实现设计模式——生成器模式
  • 小账本软件设计之数据库设计模式构建

    • 设计模式推荐文章

  • 设计模式：代理模式详解
  • 设计模式之工厂模式（学习笔记）
  • Java设计模式总结
  • Java面试题：Spring框架除了IOC和AOP，还有哪些好玩的设计模式？
  • 什么是设计模式？
  • 设计模式学习（一）单例模式的几种实现方式
  • 我们在SqlSugar开发框架中，用到的一些设计模式
  • 3分钟看懂设计模式01：策略模式
  • 设计模式浅析(三) ·装饰者模式
  • GOF23--23种设计模式（一）

    • 本站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号