设计模式之工厂模式

逃离我推掉我的手 2022-10-29 06:29 150阅读 0赞

# 案例 #

披萨项目：要便于披萨种类的扩展，要便于维护

*  披萨的种类很多（比如GreekPizz，CheesePizz等）
 *  披萨的制作有prepare，bake，cut，box
 *  完成披萨店订购功能  
    设计如下图  
    ![image][]

public abstract class Pizza { 
        protected String name;
    
        /** * 准备原材料，不同的披萨不一样 */
        public abstract void prepare();
    
        public void cut() { 
            System.out.println(name + "cutting");
        }
    
        public void bake() { 
            System.out.println(name + "baking");
        }
    
        public void box() { 
            System.out.println(name + "boxing");
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    }

public class CheesePizza extends Pizza { 
    
        @Override
        public void prepare() { 
            System.out.println("制作奶酪披萨，准备原材料中");
        }
    }

public class GreekPizza extends Pizza { 
        @Override
        public void prepare() { 
            System.out.println("给希腊披萨准备原材料中");
        }
    }

public class PepperPizza extends Pizza { 
        @Override
        public void prepare() { 
            System.out.println("给胡椒披萨准备原材料");
        }
    }

public class OrderPizza { 
        public OrderPizza() { 
            Pizza pizza = null;
            String orderType;//订购披萨的类型
            do { 
                orderType = getType();
                if (orderType.equals("greek")) { 
                    pizza = new GreekPizza();
                    pizza.setName(" greek ");
                } else if (orderType.equals("cheese")) { 
                    pizza = new CheesePizza();
                    pizza.setName(" cheese ");
                } else if (orderType.equals("pepper")){ 
                    pizza = new PepperPizza();
                    pizza.setName(" pepper ");
                } else { 
                    break;
                }
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } while (true);
        }
    
        private String getType() { 
            try { 
                BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
                System.out.println("input pizza type");
                String str = strin.readLine();
                return str;
            } catch (Exception e) { 
                System.out.println(e.getMessage());
                return "";
            }
        }
    }

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

## 改进的思路分析 ##

分析：修改代码可以接受，但是如果我们在其他地方也有创建pizza代码，就意味着也需要修改，而创建Pizza的代码往往有多处  
思路：把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类时，只需要修改该类就可以了，其他有创建到Pizza对象的代码就不需要修改了->简单工厂模式

# 简单工厂模式 #

![image][image 1]

public class CheesePizza extends Pizza { 
    
        @Override
        public void prepare() { 
            System.out.println("制作奶酪披萨，准备原材料中");
        }
    }

public class GreekPizza extends Pizza { 
        @Override
        public void prepare() { 
            System.out.println("给希腊披萨准备原材料中");
        }
    }

public class PepperPizza extends Pizza { 
        @Override
        public void prepare() { 
            System.out.println("给胡椒披萨准备原材料");
        }
    }

public class SimpleFactory { 
        public Pizza createPizza(String orderType){ 
            System.out.println("使用简单工厂模式");
            Pizza pizza = null;
            if (orderType.equals("greek")) { 
                pizza = new GreekPizza();
                pizza.setName(" greek ");
            } else if (orderType.equals("cheese")) { 
                pizza = new CheesePizza();
                pizza.setName(" cheese ");
            } else if (orderType.equals("pepper")){ 
                pizza = new PepperPizza();
                pizza.setName(" pepper ");
            }
            return pizza;
        }
    }

public class OrderPizza { 
        SimpleFactory simpleFactory;
        Pizza pizza = null;
    
        public OrderPizza(SimpleFactory simpleFactory) { 
            setFactory(simpleFactory);
        }
    
        public void setFactory(SimpleFactory simpleFactory) { 
            String orderType = "";
            this.simpleFactory = simpleFactory;
            do { 
                orderType = getType();
                pizza = this.simpleFactory.createPizza(orderType);
                if (pizza != null) { 
                    pizza.prepare();
                    pizza.bake();
                    pizza.cut();
                    pizza.box();
                } else { 
                    System.out.println(" 订购失败 ");
                    break;
                }
            } while (true);
        }
    
        private String getType() { 
            try { 
                BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
                System.out.println("input pizza type");
                String str = strin.readLine();
                return str;
            } catch (Exception e) { 
                System.out.println(e.getMessage());
                return "";
            }
        }
    }

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

## 改进后的效果 ##

当新增一种pizza类型时，只需要新增一个类，和SimpleFactory需要多写一个判断并且添加一个类型就够了，这样我们其他想创建pizza对象实例的时候，直接用SimpleFactory的create方法即可，整体代码可以有更好的方式（例如工厂内可以用枚举类判断加+反射创建类，），我这里只阐述简单工厂的思想。

# 工厂方法模式 #

## 介绍 ##

**工厂方法模式设计方案**：将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中去实现。  
**工厂方法模式**：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类  
![image][image 2]

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

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

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

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

public abstract class OrderPizza { 
        /** * 定义一个抽象方法，让各个工厂子类自己实现 * @param orderType * @return */
        abstract Pizza createPizza(String orderType);
    
        public OrderPizza() { 
            String orderType;
            Pizza pizza;
            do { 
                orderType = getType();
                pizza = createPizza(orderType);
                if (pizza != null) { 
                    pizza.prepare();
                    pizza.bake();
                    pizza.cut();
                    pizza.box();
                } else { 
                    System.out.println(" 订购失败 ");
                    break;
                }
            } while (true);
        }
    
        private String getType() { 
            try { 
                BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
                System.out.println("input pizza type");
                String str = strin.readLine();
                return str;
            } catch (Exception e) { 
                System.out.println(e.getMessage());
                return "";
            }
        }
    }

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

public class BJOrderPizza extends OrderPizza { 
        @Override
        Pizza createPizza(String orderType) { 
            Pizza pizza = null;
            if (orderType.equals("pepper")) { 
                pizza = new BJPepperPizza();
                pizza.setName(" greek ");
            } else if (orderType.equals("cheese")) { 
                pizza = new BJCheesePizza();
                pizza.setName(" cheese ");
            }
            return pizza;
        }
    }

public class PizzaStore { 
        public static void main(String[] args) { 
            new BJOrderPizza();//这里new哪个就是当地的创建形式
        }
    }

# 抽象工厂模式 #

## 基本介绍 ##

*  定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类
 *  抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合
 *  从设计层面看，抽象工厂模式就是对简单工厂模式的改进
 *  将工厂抽象为两层，AbsFactory和具体实现的工厂子类。我们可以根据创建对象类型使用对应的工厂子类。这样讲单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展  
    ![image][image 3]

public interface AbsFactory { 
        /** * 创建披萨，让下面的工厂子类自己实现 * * @param orderType * @return */
        Pizza createPizza(String orderType);
    }

public class BJFactory implements AbsFactory { 
        public Pizza createPizza(String orderType) { 
            Pizza pizza = null;
            if (orderType.equals("cheese")) { 
                pizza = new BJCheesePizza();
            } else if (orderType.equals("pepper")) { 
                pizza = new BJPepperPizza();
            }
            return pizza;
        }
    }

public class LDFactory implements AbsFactory { 
        public Pizza createPizza(String orderType) { 
            Pizza pizza = null;
            if (orderType.equals("cheese")) { 
                pizza = new LDCheesePizza();
            } else if (orderType.equals("pepper")) { 
                pizza = new LDPepperPizza();
            }
            return pizza;
        }
    }

public class OrderPizza { 
        AbsFactory factory;
    
        public OrderPizza(AbsFactory factory){ 
            setFactory(factory);
        }
    
        private void setFactory(AbsFactory factory){ 
            Pizza pizza;
            this.factory = factory;
            String orderType;
            do { 
                orderType = getType();
                pizza = factory.createPizza(orderType);
                if (pizza != null) { 
                    pizza.prepare();
                    pizza.bake();
                    pizza.cut();
                    pizza.box();
                } else { 
                    System.out.println(" 订购失败 ");
                    break;
                }
            } while (true);
        }
    
        private String getType() { 
            try { 
                BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
                System.out.println("input pizza type");
                String str = strin.readLine();
                return str;
            } catch (Exception e) { 
                System.out.println(e.getMessage());
                return "";
            }
        }
    }

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

# 小结 #

*  工厂模式的意义：将实例化对象的代码提取出来放到一个类中统一管理和维护，达到和主项目的依赖关系解耦。从而提高项目的扩展性和维护性
 *  三种工厂模式（简单工厂模式、工厂方法模式、抽象工厂模式）
 *  设计模式的依赖抽象原则

[image]: /images/20221024/17c18f03e687448e9ec4fd3b44c04e44.png
[image 1]: /images/20221024/f8d1e9ae934341bca08fae1d56de5d19.png
[image 2]: /images/20221024/11b1da5692cd4380a24ce8c5b1281566.png
[image 3]: /images/20221024/86147e4597be46a8ae89d1229d9b54fe.png