设计模式之工厂模式

本文根据尚硅谷韩顺平老师的设计模式课程编写设计模式
工厂模式包括两个设计模式：

1. 工厂方法模式
2. 抽象工厂模式

这里将这两个设计模式放在了一起

(1)，一个具体的需求

看一个披萨项目，要便于种类的扩展，要便于维护

1. 披萨的种类有很多(比如 GreekPizz，CheesePizza)
2. 披萨的制作有 prepare，bake，cut，box。
3. 完成披萨店订购功能

普通方式

1. Pizza

   //将Pizza类做成抽象的
   public abstract class Pizza {
       protected String name;
   
       //准备原材料，不同的皮塞不一样，因此，我们做成抽象类
       public abstract void prepare();
   
       public void bake() {
           System.out.println(name + "baking");
       }
   
       public void cut() {
           System.out.println(name + "cutting");
       }
   
       //打包
       public void box() {
           System.out.println(name + "boxing");
       }
   
       public void setName(String name) {
           this.name = name;
       }
   }
   

2. GreekPizz.java

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

3. CheesePizza.java

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

4. OrderPizza.java

   public class OrderPizza {
       //构造器
       public OrderPizza() {
           Pizza pizza = null;
           //订购披萨的类型
           String orderType;
           do {
               orderType = gettype();
               if (orderType.equals("greek")){
                   pizza = new GreekPizz();
                   pizza.setName(" 希腊披萨 ");
               }else if (orderType.equals("cheese")){
                   pizza = new CheesePizza();
                   pizza.setName(" 奶酪披萨 ");
               }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 (IOException e) {
               e.printStackTrace();
               return "";
           }
       }
   }
   

5. 优缺点

   • 优点是比较好理解，简单易操作
   • 缺点是违反了ocp原则，即对扩展开放，对修改关闭。
   • 比如我们这是新增一个Pizza的种类，就需要修改原来的类
   • 如果Order过多那么就需要修改很多的Order

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

(2)，简单工厂模式

介绍

• 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪种产品类的实例。 简单工厂模式是工厂模式家族
  中最简单实用的模式
• 简单工厂模式:定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)
• 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式.

改进

1. OrderPizza.java

   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);
               //输出Pizza的信息
               if (pizza != null) {
                   pizza.prepare();
                   pizza.bake();
                   pizza.cut();
                   pizza.box();
               } else {
                   System.out.println("没有这种Pizza");
                   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 (IOException e) {
               e.printStackTrace();
               return "";
           }
       }
   }
   

2. SimpleFactory.java

   //简单工厂类
   public class SimpleFactory {
   
       //根据orderType返回对应的Pizza对象
       public Pizza createPizza(String orderType) {
           Pizza pizza = null;
           System.out.println("使用简单工厂模式");
           if (orderType.equals("greek")){
               pizza = new GreekPizz();
               pizza.setName(" 希腊披萨 ");
           }else if (orderType.equals("cheese")){
               pizza = new CheesePizza();
               pizza.setName(" 奶酪披萨 ");
           }
           return pizza;
       }
   }
   

3. 如果需要新增只需要修改SimpleFactory中的代码就可以响应需求，不需要逐个修改每个Order

(3)，工厂方法模式

在工厂方法模式中不再提供一个统一的工厂类来创建所有的产品对象,而是针对不同的产品提供不同的工厂,系统提供一个与产品等级结构对应的工厂等级结构。

工厂方法模式的定义如下:

定义一个用于创建对象的接口,但是让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。

工厂方法模式简称为工厂模式( Factory Pattern),又可称作虚拟构造器模式('Virtual Constructor Pattern)或多态工厂模式( Polymorphic Factory Pattern)。

工厂方法模式是种类创建型模式。

在工厂方法模式中,工厂父类负责定义创建产品对象的公共接口,而工厂子类负责生成具体的产品对象,这样做的目的是将产品类的实例操作延迟到工厂子类中完成,即通过工厂子类来确定究竟应该实例化哪一个具体产品类

工厂方法模式包含以下4个角色。

1. Product(抽象产品):它是定义产品的接口,是工厂方法模式所创建对象的超类型，也就是产品对象的公共父类
2. ConcreteProduct(具体产品):它实现了抽象产品接口,某种类型的具体产品由专门的具体工厂创建,具体工厂和具体产品之间一一对应
3. Factory(抽象工厂):在抽象工厂类中声明了工厂方法( Factory Method),用于返回一个产品。抽象工厂是工厂方法模式的核心,所有创建对象的工厂类都必须实现该接口。
4. ConcreteFactory(具体工厂):它是抽象工厂类的子类,实现了在抽象工厂中声明的工厂方法,并可由客户端调用,返回一个具体产品类的实例

(4)，抽象工厂模式

基本介绍

1. 抽象工厂模式:定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类
2. 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
3. 从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
4. 将工厂抽象成两层，AbsFactory(抽象工厂) 和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂族，更利于代码的维护和扩展。