标签：java 披萨 factory 工厂 ---- Pizza 设计模式 public pizza

主文章（所有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. 简单工厂模式（分静态工厂和普通）
    • 2. 工厂方法模式
    • 3. 抽象工厂模式(重点)
  • 2. java源码中哪些用到了工厂设计模式

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

2. 奶酪披萨

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

3. 希腊披萨

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

4. 工厂类

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

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

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

6. 披萨店

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

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

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

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

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

}

4. 指定伦敦工厂，生产对象
   

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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。