4.工厂模式

Posted 2021-07-31 客官不爱喝酒

简单工厂模式

• • 1.简单工厂模式
  • 2.工厂方法模式
  • 3.抽象工厂模式
  • 4.JDK Calendar
  • 5.工厂模式小结

1.简单工厂模式

简单工厂模式的实际需求

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

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

1. Pizza: 抽象父类

/** 将Pizza 做成抽象类
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:51
 */
public abstract class Pizza {
    protected  String name;

    // 准备披萨 因为不太的披萨会有不同的原材料 所以做成抽象方法
    public abstract void prepare();

    public void bake(){
        System.out.println("开始烘烤");
    }

    public void cut(){
        System.out.println("开始切割");
    }

    public void box(){
        System.out.println("开始包装");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

2. CheesePizza：奶酪披萨

/** 奶酪披萨
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:54
 */
public class CheesePizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("选用奶酪披萨原材料");
    }

    @Override
    public void bake() {
       super.bake();
    }

    @Override
    public void cut() {
     super.cut();
    }

    @Override
    public void box() {
      super.box();
    }


}

3. GreekPizza：希腊披萨

/** 希腊披萨
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:55
 */
public class GreekPizza  extends Pizza{
    @Override
    public void prepare() {
        System.out.println("选用希腊披萨原材料");
    }

    @Override
    public void bake() {
      super.bake();
    }

    @Override
    public void cut() {
       super.cut();
    }

    @Override
    public void box() {
      super.cut();
    }
}

4. OrderPizza：表示披萨商店，可以根据用户的输入，制作相应的披萨

/**  披萨商店
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:57
 */
public class OrderPizza {


   public  OrderPizza( ){
       Pizza pizza=null;
       String orderType=null;
        do {
             orderType=getType();
            if ("greek".equals(orderType)){
                 pizza = new GreekPizza();
            }else if ("cheese".equals(orderType)){
                 pizza = new CheesePizza();
            }else {
                break;
            }
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while (true);

    }

    private String getType()   {

        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入需要订购的种类:");
        try {
            return br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }

    }
}

5. PizzaStore：相当于客户端，发出订购披萨的请求

/** 客户端 发出订购任务
 * @author compass
 * @version 1.0
 * @date 2021-07-06 15:12
 */
public class PizzaStore {

    public static void main(String[] args) {
        OrderPizza orderPizza = new OrderPizza();
    }
}

·传统方式的优缺点分析:
·

• 优点是比较好理解，简单易操作。
• 缺点是违反了设计模式的ocp原则，即对扩展开放(提供方)，对修改关闭(使用方)。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码.
• 比如我们这时要新增加一个Pizza的种类(Pepper披萨)，我们需要在使用方 OderPizza 中添加新的判断条件，违反开闭原则

改进思路

1. 分析： 如果说新增 Pizza 需要修改代码，这可以接受， 但是如果我们在其它的地方也有创建 Pizza 的代码，就意味着，有很多处的代码都需要修改，而且这些创建 Pizza 的代码全都是冗余代码。
2. 思路： 把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类时，只需要修改该类就可， 其它有创建到Pizza对象的代码就不需要修改了 --> 简单工厂模式

改进后的简单工厂模式;

Pizza, CheesePizza, GreekPizza：代码不变

SimpleFactory：工厂类，根据用户输入，制作相应的 Pizza，此时 SimpleFactory 为提供方

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 16:28
 */
public class SimpleFactory {

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


}

OrderPizza :表示披萨商店，可以根据用户的输入，制作相应的披萨

/**  披萨商店
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:57
 */
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();
                System.out.println();
            } else {
                System.out.println("订购披萨失败");
                break;
            }
        } while (true);
    }

    // 写一个方法，可以获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入需要订购的种类:");
            return br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

}

PizzaStore : 客户端 发出订购任务

/** 客户端 发出订购任务
 * @author compass
 * @version 1.0
 * @date 2021-07-06 15:12
 */
public class PizzaStore {

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

两者做比较：

还有一种静态简单工厂模式：也就是将 createPizza(String orderType)方法改为静态的即可，其他的地方做相应的修改即可

2.工厂方法模式

工厂方法模式的实际需求

看一个新的需求

披萨项目新的需求： 客户在点披萨时， 可以点不同口味的披萨， 比如北京的奶酪 pizza、 北京的胡椒 pizza 或者是伦敦的奶酪 pizza、 伦敦的胡椒 pizza。

思路一：简单工厂模式

• 使用简单工厂模式， 创建不同的简单工厂类， 比如 BJPizzaSimpleFactory、LDPizzaSimpleFactory 等等。

• 从当前这个案例来说， 也是可以的， 但是考虑到项目的规模， 以及软件的可维护性、 可扩展性并不是特别好，因为过多的工厂类会导致整个项目类膨胀

路二：使用工厂方法模式

工厂方法模式介绍

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

工厂方法模式应用案例

项目需求：披萨项目新的需求： 客户在点披萨时， 可以点不同口味的披萨， 比如 北京的奶酪 pizza、 北京的胡椒 pizza 或者是伦敦的奶酪 pizza、 伦敦的胡椒 pizza

1. Pizza：抽象父类，和之前的定义一样

/** 将Pizza 做成抽象类
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:51
 */
public abstract class Pizza {
    protected  String name;

    // 准备披萨 因为不太的披萨会有不同的原材料 所以做成抽象方法
    public abstract void prepare();

    public void bake(){
        System.out.println(name+":开始烘烤");
    }

    public void cut(){
        System.out.println(name+":开始切割");
    }

    public void box(){
        System.out.println(name+":开始包装");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

2. BJCheesePizza：北京的奶酪披萨

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:55
 */
public class BJCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京的奶酪pizza");
        System.out.println("北京的奶酪pizza 准备原材料");
    }


}

3. BJPepperPizza：北京的胡椒披萨

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:54
 */
public class BJPepperPizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京的胡椒pizza");
        System.out.println("北京的胡椒pizza 准备原材料");
    }




}

4. LDCheesePizza：伦敦的奶酪披萨

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:54
 */
public class LDCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setName("伦敦的奶酪pizza");
        System.out.println("伦敦的奶酪pizza 准备原材料");
    }




}

5. LDPepperPizza：伦敦的胡椒披萨

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:55
 */
public class LDPepperPizza extends Pizza {
    @Override
    public void prepare() {
        setName("伦敦的胡椒pizza");
        System.out.println("伦敦的胡椒pizza 准备原材料");
    }


}

6. OrderPizza：含有抽象方法的工厂父类，其抽象方法待子类去实现

/**  含有抽象方法的工厂父类，其抽象方法待子类去实现
 * @author compass
 * @version 1.0
 * @date 2021-07-06 14:57
 */
public abstract  class OrderPizza {

    // 定义一个抽象方法，createPizza , 让各个工厂子类自己实现
    abstract Pizza createPizza(String orderType);

    // 构造器
    public OrderPizza() {
        Pizza pizza = null;
        String orderType; // 订购披萨的类型
        do {
            orderType = getType();
            pizza = createPizza(orderType); // 抽象方法，由工厂子类完成
            // 输出pizza 制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
            System.out.println();
        } while (true);
    }

    // 写一个方法，可以获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 种类:");
            return br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

}

7. BJOrderFactory：北京披萨的生产工厂

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 17:57
 */
public class BJOrderFactory  extends OrderPizza{
    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new BJPepperPizza();
        }
        return pizza;
    }

}

8. LDOrderFactory：伦敦披萨的生产工厂

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 17:57
 */
public class LDOrderFactory   extends OrderPizza{

        @Override
        Pizza createPizza(String orderType) {
            Pizza pizza = null;
            if (orderType.equals("cheese")) {
                pizza = new LDCheesePizza();
            } else if (orderType.equals("pepper")) {
                pizza = new LDPepperPizza();
            }
            return pizza;
        }



}

9. PizzaStore：相当于客户端，发出订购披萨的请求

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 18:00
 */
public class PizzaStore {

    public static void main(String[] args) {
        String loc = "bj"; // 假设这里是用户输入的位置信息
        if (loc.equals("bj")) {
            // 创建北京口味的各种Pizza
            new BJOrderFactory();
        } else {
            // 创建伦敦口味的各种Pizza
            new LDOrderFactory();
        }
    }

}

3.抽象工厂模式

抽象工厂模式的基本介绍

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

抽象工厂模式的案例

使用抽象工厂模式来完成披萨项目

代码实现

Pizza抽象父类以及Pizza的子类和上面一样

AbsFactory：工厂抽象层，定义制造 Bean 的抽象方法

/** 一个抽象工厂模式的抽象层（接口）
 * @author compass
 * @version 1.0
 * @date 2021-07-06 20:43
 */
public interface AbsFactory {

    Pizza createPizza(String orderType);
 }

BJFactory：北京工厂子类（提供方），负责制造北京各种口味的 Pizza

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 20:45
 */
public class BJFactory implements AbsFactory {
    @Override
    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;
    }
}

LDFactory：伦敦工厂子类（提供方），负责制造伦敦各种口味的 Pizza

/**
 * @author compass
 * @version 1.0
 * @date 2021-07-06 20:45
 */
public class LDFactory  implements AbsFactory{
    @Override
    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;
    }
}

OrderPizza：使用方，负责消费 Pizza

以上是关于4.工厂模式的主要内容，如果未能解决你的问题，请参考以下文章
 
 设计模式 创建者模式 工厂设计模式 -- 抽象工厂设计模式介绍和实现
 设计模式之工厂模式
 Java设计模式图文代码案例详解Java五大创建者模式 建造者原型(抽象)工厂单例模式
 4.抽象工厂模式
 设计模式-4-抽象工厂
 工厂模式——结语