Head First Design Patterns——工厂方法模式

Bertha 。 2023-07-22 09:03 233阅读 0赞

> 我们现在要添加一个功用，那就是订购披萨，根据不同的地方特色来订购，例如，BJCheessPizza,BJPepoperPizza，LDChessPizza等种类，此时，我们可以将OrderPizza类中的createPizza（）方法定义为abstract类型，谁调用就实现这个方法，然后对应的种类就实现功能了  
> 下面的是类图的表示形式：

![抱歉！会设计模式就是很牛——简单工厂模式（静态工厂）][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mjg5MzA4NQ_size_16_color_FFFFFF_t_70]

> 当然，这是在上篇的基础上改的，如果没有了解的参照：

*  [抱歉！会设计模式就是很牛——简单工厂模式（静态工厂）][Link 1]  
    大家在学习的时候主要结合例子，原理才是核心，如果不太懂的话还是学习一下UML类图，相信对你会有很大的帮助。下面让我们来用代码实现：
 *  Pizza (将Pizza类定义为abstract，还有抽象 方法prepare())

public abstract  class Pizza { 
    
        private String name;
    
        public abstract void prepare();
    
        public void bake() { 
            System.out.println("baking;");
        }
    
        public void cut() { 
            System.out.println("cuting;");
        }
    
        public void box() { 
            System.out.println("boxing;");
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    }

*  BJChessPizza

public class BJChessPizza extends  Pizza{ 
        @Override
        public void prepare() { 
            setName("北京奶酪披萨");
            System.out.println("北京奶酪披萨BjChessPizza 准备原材料");
        }
    }

*  BJPepperPizza

public class BJPepperPizza extends  Pizza{ 
        @Override
        public void prepare() { 
            setName("BJPepperPizza");
            System.out.println("BJPepperPizza 准备原材料");
        }
    }

*  LDChessPizza

public class LDChessPizza extends  Pizza{ 
        @Override
        public void prepare() { 
            setName("伦敦奶酪披萨");
            System.out.println("LDChessPizza 准备原材料");
        }
    }

*  LDPepperPizza

public class LDPepperPizza extends  Pizza{ 
        @Override
        public void prepare() { 
            setName("LDPepperPizza");
            System.out.println("LDPepperPizza 准备原材料");
        }
    }

*  BJOrderPizza

public class BJOrderPizza extends OrderPizza2{ 
    
        @Override
        Pizza createPizza(String orderType) { 
            Pizza pizza = null;
            if (orderType.equals("chess")){ 
                pizza = new BJChessPizza();
            }else if (orderType.equals("pepper")){ 
                pizza = new BJPepperPizza();
            }
            return pizza;
        }
    }

*  LDOrderPizza

public class LDOrderPizza extends OrderPizza2{ 
    
        @Override
        Pizza createPizza(String orderType) { 
            Pizza pizza = null;
            if (orderType.equals("cheese")){ 
                pizza = new LDChessPizza();
            }else if (orderType.equals("pepper")){ 
                pizza = new LDPepperPizza();
            }
            return pizza;
        }
    }

*  OrderPizza2 (这个类并不处理具体new的是哪个 对象，而是根据输入的类型，交给子类指定的OrderPizza来处理，只是负责调用)

public abstract class OrderPizza2 { 
    
        //定义一个抽象方法，createPizza,让各个工厂子类自己实现
        abstract Pizza createPizza(String orderType);
    
        Pizza pizza;
    
        public OrderPizza2() { 
            String orderType;
            do { 
                orderType = getype();
                pizza = createPizza(orderType);//抽象方法，由工厂子类来完成
    
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } while (true);
        }
    
        //写一个方法，可以获取客户端希望订购的披萨种类
        private String getype(){ 
            try { 
                BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
                System.out.println("input Pizza type:");
                String str = strin.readLine();
                return str;
            }catch (IOException e){ 
                e.printStackTrace();
                return "";
            }
        }
    }

*  PizzaStore

public class PizzaStore { 
        public static void main(String[] args) { 
            new BJOrderPizza();
        }
    }

*  运行结果  
    ![在这里插入图片描述][20200405212336506.png_pic_center]

> 总结：工厂方法模式就是按类型创建时，将每一个类型都交给他们自己的工厂来生产，然后再由用一个类来按照传入的类型来创建，具体的实现都交给他们的子类来完成，也可以用“工厂的工厂”来形容！

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mjg5MzA4NQ_size_16_color_FFFFFF_t_70_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mjg5MzA4NQ_size_16_color_FFFFFF_t_70]: /images/20230528/64b53ee6c7dd4d0ab71556d7c2f8cd12.png
[Link 1]: https://blog.csdn.net/weixin_42893085/article/details/105309872
[20200405212336506.png_pic_center]: /images/20230528/a66f9c42f1ed4b928862872befcae187.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mjg5MzA4NQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20230528/98e6b510c0944a9984097573887e4e09.png