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

最新推荐文章于 2024-07-10 09:55:34 发布

殷丿grd_志鹏

最新推荐文章于 2024-07-10 09:55:34 发布

阅读量422

点赞数

分类专栏：编程基础知识文章标签： java 开发语言后端设计模式

本文链接：https://blog.csdn.net/grd_java/article/details/122319280

版权

编程基础知识专栏收录该内容

23 篇文章 2 订阅

订阅专栏

主文章（所有java设计模式的目录）
https://blog.csdn.net/grd_java/article/details/122252696

源码位置
码云：https://gitee.com/yin_zhipeng/design_mode.git
GitHub：

学习设计模式前必须知道的东西

看待设计模式，要站在更大的角度（代码重用性、可读性、可扩展性、可靠性、程序高内聚，低耦合）来综合考虑看待，而不是功能实现的角度看待，不要觉得实现一个功能没必要这么麻烦

文章中给出的设计模式类图都是标准的实现方式，并不一定要完全遵守标准，所以只要设计思想符合，一个设计模式有多种实现方式，尤其是看别人源码的时候，不要用标准类图死扣

通过一个实际案例讲解，订购披萨项目（工厂其实就是一个生产披萨的工厂）

便于披萨种类扩展，便于维护
披萨种类很多（GreekPizza、CheesePizza等等）
披萨制作有prepare、bake、cut、box
完成披萨店订购功能、

文章目录

1. 工厂设计模式

1. 简单工厂模式（分静态工厂和普通）

工厂就是生产特定对象的厂子，无论日后你生产的对象做如何改变，只需要工厂知道即可，用户无需关注,假设1个工厂和1000个用户，我们日后改变对象，只需要改变工厂代码，而不需要改变1000个用户的代码
静态工厂：生产出对象的方法是静态的
普通工厂：生产出对象的方法不是静态的

类图：类图位置com/yzpnb/design_mode/factory/easy_factory/tradition/Pizza.puml

代码都在：com/yzpnb/design_mode/factory/easy_factory/tradition包下

运行效果

问题分析

违反设计模式的ocp原则，即不满足对扩展开放，对修改关闭。我们给类增加新功能时，应该尽量保证用户使用你的产品，不修改，或少修改代码。
解析问题（下面代码判断用户想要那种披萨，然后执行相应逻辑，当我们增加一个类的时候，下面代码也需要做改变）

问题严重性，这里订单类用到这段代码，假设这时需要一个新的类，负责给不同类型披萨打折。那么又需要复制这些代码。
假设这时候我们再增加一个种类，那么两个类的代码都需要改变
而实际开发中往往有几十，甚至成百上千个类

如何改进呢，就需要用到工厂模式

简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例，是工厂模式中最简单实用的模式
定义一个创建对象的类，由这个类封装实例对象的行为
软件开发中，需要大量的创建某种、某类或某批对象时，就会用到工厂模式

改进后类图：com/yzpnb/design_mode/factory/easy_factory/improved/Pizza.puml

因为有了工厂类的存在，所以当我们增加种类，只需要让工厂知道即可，OrderPizza类不需要做改变

代码全部在：com/yzpnb/design_mode/factory/easy_factory/improved/下

抽象类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;
    }
}

奶酪披萨

public class CheessPizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("添加奶酪披萨原材料！！！");
    }
}

希腊披萨

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

工厂类

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;
    }
}

订单(这里使用了工厂类的静态方法，使用的静态工厂)

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 "";
        }
    }
}

披萨店

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. 工厂方法模式

假设我们有新的需求，客户点披萨时，可以点不同地方的披萨，比如北京的奶酪披萨或伦敦的奶酪披萨

方案一：使用简单工厂模式，创建不同简单工厂类，比如BeijingPizzaSimpleFactory或LondonPizzaSimpleFactory，虽然可行，但是考虑未来项目规模，软件的可维护性、可扩展性并不好。
方案二：使用工厂方法模式

定义一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类
将披萨项目到的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现
通俗的讲就是，总工厂规定制作流程（抽象方法），北京等子工厂负责根据总工厂规定流程制作披萨（实现抽象方法），用户想要披萨，直接和北京等子工厂要（不与总工厂接触），子工厂做出来后，最后可以由父工厂发货

我们可以子工厂单纯生产出披萨对象，剩下的方法由父工厂来调用

类图：com/yzpnb/design_mode/factory/method_factory/Pizza.puml

代码：com/yzpnb/design_mode/factory/method_factory/pizzastore包下

运行效果

如何抽象方法工厂？(子工厂生产对象，父工厂负责执行操作，切割、装箱、发货等)

如何使用？

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

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

总结成一句话就是：我们下订单，直接指定下的是伦敦或其它某一个工厂的订单，你直接去操作把对应的比如伦敦的披萨给我就行

伦敦工厂会根据总工厂的规定，创造披萨

类图：com/yzpnb/design_mode/factory/absfactory/Pizza.puml

代码：com/yzpnb/design_mode/factory/absfactory包下

定义抽象工厂接口

//抽象工厂模式的抽象层（接口）
public interface AbsFactory {
    //抽象方法，子工厂具体实现
    public Pizza createPizza(String orderType);
}

子工厂(实现抽象方法，生产对象)

//子工厂
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;
    }
}

订单，使用指定工厂生产对象，并处理对象

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 "";
		}
	}

}

指定伦敦工厂，生产对象

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

java JDK的Calendar类使用静态简单工厂

类图：com/yzpnb/design_mode/factory/source_analysis/Calendar.puml

分析

通过静态方法，获取对象

根据是否传入时区和地区，调用创建对象方法，没传就用默认值

创建对象方法，如果时区和地区是默认值，直接返回provide的实例，不是默认，根据你的地区和时区，选择不同工厂返回provide实例