欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

十二 设计模式--工厂模式1(简单工厂模式)

程序员文章站 2024-02-26 19:44:52
...

1 用实例引出问题

首先我们先用一个实例来引出问题.

1.1 实例需求

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

  1. 披萨的种类很多(比如 GreekPizz、CheesePizz 等)
  2. 披萨的制作有 prepare(准备原材料),bake(烘烤), cut(切割), box(打包)
  3. 完成披萨店订购功能。

2 传统方法完成实例

2.1 使用传统方法的类图

十二 设计模式--工厂模式1(简单工厂模式)
类图说明:
有一个抽象类Pizza的类,里面有制作pizza的各种方法,而CheessPizza(奶酪披萨)和GreekPizza(希腊披萨)都继承于Pizza类.OrderPizza是用来完成Pizza订单的,它依赖于(用到)GreekPizza和CheessPizza.

2.2 代码实现

Pizza 类

package com.andy.factory.simplefactory.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;
    }
}

CheesePizza 类

package com.andy.factory.simplefactory.pizza;

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

GreekPizza 类

package com.andy.factory.simplefactory.pizza;

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

OrderPizza 类

package com.andy.factory.simplefactory.order;

import com.andy.factory.simplefactory.pizza.CheesePizza;
import com.andy.factory.simplefactory.pizza.GreekPizza;
import com.andy.factory.simplefactory.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class OrderPizza {
    public OrderPizza() {
        Pizza pizza = null;
        String orderType;
        do {
            orderType = getType();
            if ("greek".equals(orderType)){
                pizza = new GreekPizza();
                pizza.setName(" 希腊披萨 ");

            }else if ("cheess".equals(orderType)){
                pizza = new CheesePizza();
                pizza.setName("奶酪披萨");

            }else{
                System.out.println(" 订购披萨失败 ");
                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("请输入披萨的种类: ");
            String str = strin.readLine();
            return str;
        }catch (IOException e){
            e.printStackTrace();
            return "";
        }
    }
}

PizzaStory 类

package com.andy.factory.simplefactory.order;

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

2.3 分析传统的方式的优缺点

  1. 优点是比较好理解,简单易操作。
  2. 缺点是违反了设计模式的ocp原则,即对扩展开放,对修改关闭。即当我们给类增加新功能的时候,尽量不修改代码,或者尽可能少修改代码.
  3. 比如我们这时要新增加一个Pizza的种类(Pepper披萨),我们需要做如下修改.
    3-1. 增加一个PepperPizza 类
package com.andy.factory.simplefactory.pizza;

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

3-2. 更改OrderPizza类的构造函数如下(违反开闭原则)

public OrderPizza() {
        Pizza pizza = null;
        String orderType;
        do {
            orderType = getType();
            if ("greek".equals(orderType)){
                pizza = new GreekPizza();
                pizza.setName(" 希腊披萨 ");

            }else if ("cheess".equals(orderType)){ 
                pizza = new CheesePizza();
                pizza.setName("奶酪披萨");

            }else if ("pepper".equals(orderType)){//增加胡椒披萨的处理
                pizza = new PepperPizza();
                pizza.setName("胡椒披萨");

            }else{
                System.out.println(" 订购披萨失败 ");
                break;
            }

            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while (true);
    }
  1. 改进的思路分析
    分析:修改代码可以接受,但是如果我们在其它的地方也有创建Pizza的代码,就意味着,也需要修改,而创建Pizza的代码,往往有多处。
    思路:把创建Pizza对象封装到一个类中,这样我们有新的Pizza种类时,只需要修改该类就可,其它有创建到Pizza对象的代码就不需要修改了.这就是我们要介绍的 简单工厂模式.

3 简单工厂模式的介绍

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

4 使用简单工厂模式

简单工厂模式的设计方案: 定义一个可以实例化Pizaa对象的类,封装创建对象的代码。

4.1 改进类图

十二 设计模式--工厂模式1(简单工厂模式)
分析:
如上图所示我们在原来的基础上增加一个SimpleFactory类 用它来聚合所有的订单,并且它依赖于所有种类的Pizza类.这样如果增加一个种类的pizza就不用改orderpizza类,只需要改动SimpleFactory类就可以了.

4.2 代码实现

改动的地方只有增加一个SimplePizza 类和改动OderPizza类,其他地方都不用动.
SimplePizza 类:

package com.andy.factory.simplefactory.order;

import com.andy.factory.simplefactory.pizza.CheesePizza;
import com.andy.factory.simplefactory.pizza.GreekPizza;
import com.andy.factory.simplefactory.pizza.PepperPizza;
import com.andy.factory.simplefactory.pizza.Pizza;

public class SimplePizza {
    public static Pizza createPizza(String orderType){
        Pizza pizza = null;
        System.out.println("使用简单工厂模式");
        if ("greek".equals(orderType)){
            pizza = new GreekPizza();
            pizza.setName(" 希腊披萨 ");

        }else if ("cheess".equals(orderType)){
            pizza = new CheesePizza();
            pizza.setName("奶酪披萨");

        }else if ("pepper".equals(orderType)){//增加胡椒披萨的处理
            pizza = new PepperPizza();
            pizza.setName("胡椒披萨");
        }
        return pizza;
    }
}

OrderPizza 类:

package com.andy.factory.simplefactory.order;

import com.andy.factory.simplefactory.pizza.CheesePizza;
import com.andy.factory.simplefactory.pizza.GreekPizza;
import com.andy.factory.simplefactory.pizza.PepperPizza;
import com.andy.factory.simplefactory.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class OrderPizza {
    public OrderPizza() {
        Pizza pizza = null;
        String orderType;
        do {
            orderType = getType();
            pizza = SimplePizza.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("请输入披萨的种类: ");
            String str = strin.readLine();
            return str;
        }catch (IOException e){
            e.printStackTrace();
            return "";
        }
    }
}

分析:
就像上面的改动一样,增加SimplePizza类,这样增加新的Pizza种类的时候就可以在SimplePizza类的createPizza方法中增加对应的判断语句就可以了,不用去带动OrderPizza类(假如有很多的OrderPizza类,这样改动就会很多).这就是简单工厂模式.