系列文章目录

披萨订购—传统方式

文章目录

系列文章目录
前言
一、传统方式案例
- 1.具体需求案例
- 2.传统方式实现
- 3.传统方式优缺点
总结

前言

Hello，小伙伴们，欢迎来到柚子的博客~让我们一起成长吧o(￣▽￣)ブ

提示：以下是本篇文章正文内容，下面案例可供参考

一、传统方式案例

1.具体需求案例

我们来看一个披萨的项目：要便于披萨种类的扩展，要便于维护
（1）披萨的种类很多（比如 GreekPizz、CheesePizz等）
（2）披萨的制作有 prepare，bake，cut，box
（3）完成披萨店订购功能。
在这里插入图片描述

2.传统方式实现

在这里插入图片描述

（1）创建一个披萨抽象类：

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 + " cuting;");
	}
	//打包
	public void box() {
		System.out.println(name + " boxing;");
	}
	public void setName(String name) {
		this.name = name;
	}
}

分析：这个类用来代表制作披萨的整个流程：准备阶段prepare()、烘烤阶段bake()、切割阶段cut()和打包阶段box() ，假设各个披萨的准备阶段需要的材料不一样，所以把准备阶段定义为一个抽象方法，其它三个阶段都一样。

（2）创建一个奶酪披萨类：

public class CheesePizza extends Pizza {
	@Override
	public void prepare() {
		//重写准备阶段方法
		System.out,println("给制作奶酪披萨 准备原材料");
	}
}

（3）创建一个希腊披萨类：

public class GreekPizza extends Pizza {
	public void prepare() {
		//重写准备阶段方法
		System.out,println("给制作希腊披萨 准备原材料");
	}
}

（4）创建一个订购披萨类：

public class OrderPizza {
	//构造器
	public OrderPizza() {
		Pizza pizza = null;
		String pizzaType;
		do {
			pizzaType = getType();
			if ("cheese".equals(pizzaType)) {
				pizza = new CheesePizza();
				pizza.setName("奶酪披萨");
			} else if ("greek".equals(pizzaType)) {
				pizza = new GreekPizza();
				pizza.setName("希腊披萨");
			} else {
				break;
			}
			//输出pizza 制作过程
			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("input pizza type:");
			String str = strin.readLine();
			return str;
		} catch (IOException e) {
			e.printStackTrace();
			return "";
		}
	}
}

分析：订购披萨的逻辑代码写在了该类的构造器中，getType()方法是用来获取希望订购的披萨种类。但是，如果我们需要添加新的披萨，就需要从这个类中继续添加相应的逻辑语句，从而修改了订购披萨的这个类，就违反了OCP原则

（5）创建披萨订购运行类：

//相当于一个客户端，发出订购
public class PizzaStore {
	public static void main(String[] args) {
		new OrderPizza();
	}
}

3.传统方式优缺点

（1）优点是比较好理解，简单易操作。
（2）缺点是违反了设计模式的ocp模式，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码。
（3）比如我们这时要新增加一个Pizza的种类(Pepper胡椒披萨)，我们要做如下修改。
在这里插入图片描述

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

//增加一段代码 OrderPizza.java //写
	if (orderType.equals("greek")) {
		pizza = new GreekPizza();
		pizza.setName("希腊披萨");
	} else if (orderType.equals("cheese")) {
		pizza = new CheesePizza(); 
		pizza.setName("奶酪披萨");
	} else if (orderType.equals("pepper")) {
		pizza = new PepperPizza();
		pizza.setName("胡椒披萨");
	} else {
		break;
	}
}

（4）改进的思路分析
分析： 修改代码可以接受，但是如果我们在其他的地方也有创建Pizza的代码，就意味着，也需要修改，而创建Pizza的代码，往往有多处。
思路： 把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类时，只需要修改类就可，其他有创建到Pizza对象的代码就不需要修改了——>简单工厂模式。