编程语言
首页 > 编程语言> > java设计模式----工厂设计模式

java设计模式----工厂设计模式

作者:互联网

主文章(所有java设计模式的目录)
https://blog.csdn.net/grd_java/article/details/122252696
源码位置
码云:https://gitee.com/yin_zhipeng/design_mode.git
GitHub:
通过一个实际案例讲解,订购披萨项目(工厂其实就是一个生产披萨的工厂)
  1. 便于披萨种类扩展,便于维护
  2. 披萨种类很多(GreekPizza、CheesePizza等等)
  3. 披萨制作有prepare、bake、cut、box
  4. 完成披萨店订购功能、

文章目录

1. 工厂设计模式

1. 简单工厂模式(分静态工厂和普通)

工厂就是生产特定对象的厂子,无论日后你生产的对象做如何改变,只需要工厂知道即可,用户无需关注,假设1个工厂和1000个用户,我们日后改变对象,只需要改变工厂代码,而不需要改变1000个用户的代码
静态工厂:生产出对象的方法是静态的
普通工厂:生产出对象的方法不是静态的
类图:类图位置com/yzpnb/design_mode/factory/easy_factory/tradition/Pizza.puml

在这里插入图片描述

代码都在:com/yzpnb/design_mode/factory/easy_factory/tradition包下
  1. 运行效果
    在这里插入图片描述
问题分析
  1. 违反设计模式的ocp原则,即不满足对扩展开放,对修改关闭。我们给类增加新功能时,应该尽量保证用户使用你的产品,不修改,或少修改代码。
  2. 解析问题(下面代码判断用户想要那种披萨,然后执行相应逻辑,当我们增加一个类的时候,下面代码也需要做改变)
    在这里插入图片描述
  3. 问题严重性,这里订单类用到这段代码,假设这时需要一个新的类,负责给不同类型披萨打折。那么又需要复制这些代码。
  4. 假设这时候我们再增加一个种类,那么两个类的代码都需要改变
  5. 而实际开发中往往有几十,甚至成百上千个类
如何改进呢,就需要用到工厂模式
  1. 简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例,是工厂模式中最简单实用的模式
  2. 定义一个创建对象的类,由这个类封装实例对象的行为
  3. 软件开发中,需要大量的创建某种、某类或某批对象时,就会用到工厂模式
改进后类图:com/yzpnb/design_mode/factory/easy_factory/improved/Pizza.puml

在这里插入图片描述

  1. 因为有了工厂类的存在,所以当我们增加种类,只需要让工厂知道即可,OrderPizza类不需要做改变
代码全部在:com/yzpnb/design_mode/factory/easy_factory/improved/下
  1. 抽象类Pizza
//将Pizza类做成抽象
public abstract class Pizza {
    protected String name;//名字

    //准备原材料,不同Pizza不一样,因此,做成抽象方法
    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;
    }
}
  1. 奶酪披萨
public class CheessPizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("添加奶酪披萨原材料!!!");
    }
}
  1. 希腊披萨
public class GreekPizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("添加希腊披萨原材料!!!");
    }
}
  1. 工厂类
import com.yzpnb.design_mode.factory.easy_factory.improved.pizza.CheessPizza;
import com.yzpnb.design_mode.factory.easy_factory.improved.pizza.GreekPizza;
import com.yzpnb.design_mode.factory.easy_factory.improved.pizza.Pizza;

public class SimpleFactory {
    //构建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 CheessPizza();
            pizza.setName(" 奶酪披萨 ");
        }
        return pizza;
    }

    //简单工厂模式 也叫 静态工厂模式
    //将获取对象的方法,做成静态
    public static Pizza createPizza2(String orderType) {

        Pizza pizza = null;

        System.out.println("使用简单工厂模式2");
        if (orderType.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName(" 希腊披萨 ");
        } else if (orderType.equals("cheese")) {
            pizza = new CheessPizza();
            pizza.setName(" 奶酪披萨 ");
        }
        return pizza;
    }
}
  1. 订单(这里使用了工厂类的静态方法,使用的静态工厂)
import com.yzpnb.design_mode.factory.easy_factory.improved.factory.SimpleFactory;
import com.yzpnb.design_mode.factory.easy_factory.improved.pizza.Pizza;

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

public class OrderPizza2 {
    Pizza pizza = null;
    String orderType = "";
    // 构造器
    public OrderPizza2() {

        do {
            orderType = getType();
            pizza = SimpleFactory.createPizza2(orderType);

            // 输出pizza
            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 种类:");
            String str = strin.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}
  1. 披萨店
import com.yzpnb.design_mode.factory.easy_factory.improved.factory.SimpleFactory;
import com.yzpnb.design_mode.factory.easy_factory.improved.order.OrderPizza;
import com.yzpnb.design_mode.factory.easy_factory.improved.order.OrderPizza2;

/**
 * 改进版,使用工厂模式
 */
public class PizzaShop {
    public static void main(String[] args) {
        //OrderPizza orderPizza = new OrderPizza(new SimpleFactory());
        OrderPizza2 orderPizza2 = new OrderPizza2();
    }
}

2. 工厂方法模式

假设我们有新的需求,客户点披萨时,可以点不同地方的披萨,比如北京的奶酪披萨或伦敦的奶酪披萨
  1. 方案一:使用简单工厂模式,创建不同简单工厂类,比如BeijingPizzaSimpleFactory或LondonPizzaSimpleFactory,虽然可行,但是考虑未来项目规模,软件的可维护性、可扩展性并不好。
  2. 方案二:使用工厂方法模式
  1. 定义一个创建对象的抽象方法,由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类
  2. 将披萨项目到的实例化功能抽象成抽象方法,在不同的口味点餐子类中具体实现
  3. 通俗的讲就是,总工厂规定制作流程(抽象方法),北京等子工厂负责根据总工厂规定流程制作披萨(实现抽象方法)用户想要披萨,直接北京等子工厂要(不与总工厂接触),子工厂做出来后,最后可以由父工厂发货
  1. 我们可以子工厂单纯生产出披萨对象,剩下的方法由父工厂来调用
类图:com/yzpnb/design_mode/factory/method_factory/Pizza.puml

在这里插入图片描述

代码:com/yzpnb/design_mode/factory/method_factory/pizzastore包下
  1. 运行效果
    在这里插入图片描述
  2. 如何抽象方法工厂?(子工厂生产对象,父工厂负责执行操作,切割、装箱、发货等)
    在这里插入图片描述
    在这里插入图片描述
  3. 如何使用?
    在这里插入图片描述

3. 抽象工厂模式(重点)

  1. 抽象工厂模式:定义一个interface用于创建相关或由依赖关系的对象簇,而无需指明具体的类
  2. 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合
  3. 设计层面看,抽象工厂模式就是对简单工厂模式的改进(或者称为进一步抽象)
  4. 工厂抽象成两层AbsFactory(抽象工厂)和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类,这样将单个简单工厂变成工厂簇,更利于代码的维护和扩展
总结成一句话就是:我们下订单,直接指定下的是伦敦或其它某一个工厂的订单,你直接去操作把对应的比如伦敦的披萨给我就行
  1. 伦敦工厂会根据总工厂的规定,创造披萨
类图:com/yzpnb/design_mode/factory/absfactory/Pizza.puml

在这里插入图片描述

代码:com/yzpnb/design_mode/factory/absfactory包下
  1. 定义抽象工厂接口
    在这里插入图片描述
//抽象工厂模式的抽象层(接口)
public interface AbsFactory {
    //抽象方法,子工厂具体实现
    public Pizza createPizza(String orderType);
}
  1. 子工厂(实现抽象方法,生产对象)
    在这里插入图片描述
    在这里插入图片描述
//子工厂
public class BJFactory implements AbsFactory{
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("抽象工厂模式,北京子工厂");
        Pizza pizza = null;
        if(orderType.equals("cheese")){
            pizza = new BJCheesePizza();
        }else{
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}
//子工厂
public class LDFactory implements AbsFactory{
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("抽象工厂模式,伦敦子工厂");
        Pizza pizza = null;
        if(orderType.equals("cheese")){
            pizza = new LDCheesePizza();
        }else{
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}
  1. 订单,使用指定工厂生产对象,并处理对象
    在这里插入图片描述
public abstract class OrderPizza {

	AbsFactory factory;

	/**
	 * 构造函数,传入工厂
	 * @param factory 指定工厂,创造对应对象
	 */
	public OrderPizza(AbsFactory factory){
		setFactory(factory);
	}
	//需要用户自己传入工厂
	private void setFactory(AbsFactory factory){
		Pizza pizza = null;
		String orderType = "";//用户输入
		this.factory = factory;
		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 :");
			String str = strin.readLine();
			return str;
		} catch (IOException e) {
			e.printStackTrace();
			return "";
		}
	}

}
  1. 指定伦敦工厂,生产对象
    在这里插入图片描述

2. java源码中哪些用到了工厂设计模式

java JDK的Calendar类使用静态简单工厂
  1. 类图:com/yzpnb/design_mode/factory/source_analysis/Calendar.puml
    在这里插入图片描述
  2. 分析
  1. 通过静态方法,获取对象
    在这里插入图片描述
  2. 根据是否传入时区和地区,调用创建对象方法,没传就用默认值
    在这里插入图片描述
  3. 创建对象方法,如果时区和地区是默认值,直接返回provide的实例,不是默认,根据你的地区和时区,选择不同工厂返回provide实例
    在这里插入图片描述
    在这里插入图片描述

标签:java,披萨,factory,工厂,----,Pizza,设计模式,public,pizza
来源: https://blog.csdn.net/grd_java/article/details/122319280