天天看点
返回

十二 设计模式--工厂模式1(简单工厂模式)1 用实例引出问题2 传统方法完成实例3 简单工厂模式的介绍4 使用简单工厂模式

文章目录

  • 1 用实例引出问题
    • 1.1 实例需求
  • 2 传统方法完成实例
    • 2.1 使用传统方法的类图
    • 2.2 代码实现
    • 2.3 分析传统的方式的优缺点
  • 3 简单工厂模式的介绍
  • 4 使用简单工厂模式
    • 4.1 改进类图
    • 4.2 代码实现

1 用实例引出问题

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

1.1 实例需求

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

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

2 传统方法完成实例

2.1 使用传统方法的类图

十二 设计模式--工厂模式1(简单工厂模式)1 用实例引出问题2 传统方法完成实例3 简单工厂模式的介绍4 使用简单工厂模式

类图说明:

有一个抽象类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(简单工厂模式)1 用实例引出问题2 传统方法完成实例3 简单工厂模式的介绍4 使用简单工厂模式

分析:

如上图所示我们在原来的基础上增加一个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类,这样改动就会很多).这就是简单工厂模式.

设计模式学习笔记 java 设计模式
上一篇: 设计模式 —— 工厂模式（简单工厂、工厂方法、抽象工厂）一、简单工厂模式二、简单工厂三、工厂方法模式四、抽象工厂模式五、工厂模式在 JDK-Calendar 应用的源码分析六、工厂模式小结
下一篇: 普通工厂模式、工厂方法模式、抽象工厂模式

继续阅读