简单工厂模式
案例：
披萨的项目（要便于披萨种类的扩展，要便于维护）
1)披萨的种类很多(比如 GreekPizz、CheesePizz 等)
2)披萨的制作有 prepare，bake, cut, box
3)完成披萨店订购功能。
使用传统的方式来完成
编写 OrderPizza.java 去订购需要的各种 Pizza
Pizza类
package com.lin.simplefactory;
public class SimpleFactoryDemo {
}
abstract class Pizza{
private String name;
public void setName(String name) {
this.name = name;
}
public void prepare() {
System.out.println(name + " are prepared!");
}
public void bake() {
System.out.println(name + " are baked!");
}
public void cut() {
System.out.println(name + " are cutted!");
}
public void box() {
System.out.println(name + " are boxed!");
}
}
// chesspizza
class ChessPizza extends Pizza{
}
// greekpizza
class GreekPizza extends Pizza{
}
// chinapizza
class ChinaPizza extends Pizza{
}
OrderPizza类
package com.lin.simplefactory; import java.util.Scanner;
/**
* 假如有很多orderpizza，如果增加一种pizza种类，修改就很麻烦，效率低
* @Description:
* @author LinZM
* @date 2021-2-3 0:29:26
* @version V1.8
*/
public class OrderPizza { public OrderPizza(){
Pizza pizza = null;
String orderType;
while(true) {
orderType = getType();
if(orderType.equals("chess")) {
pizza = new ChessPizza();
pizza.setName("chesspizza");
} else if(orderType.equals("greek")) {
pizza = new ChessPizza();
pizza.setName("greekpizza");
} else if(orderType.equals("china")) {
pizza = new ChessPizza();
pizza.setName("chinapizza");
} else {
break;
}
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
}
}public String getType() { Scanner str = new Scanner(System.in);
System.out.println("please input the type of ordered pizza:");
String type = str.next();
return type;
}
}
PizzaStore类
package com.lin.simplefactory;
public class PizzaStore {
public static void main(String[] args) {
new OrderPizza();
}
}
传统的方式的优缺点
1)优点是比较好理解，简单易操作。
2)缺点是违反了设计模式的 ocp 原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码.
3)比如我们这时要新增加一个 Pizza 的种类(Pepper 披萨)，我们需要做如下修改. 如果我们增加一个 Pizza 类，只要是订购 Pizza 的代码都需要修改.
改进的思路分析
分析：修改代码可以接受，但是如果我们在其它的地方也有创建 Pizza 的代码，就意味着，也需要修改，而创建 Pizza
的代码，往往有多处。
思路：把创建 Pizza 对象封装到一个类中，这样我们有新的 Pizza 种类时，只需要修改该类就可，其它有创建到 Pizza
对象的代码就不需要修改了.-> 简单工厂模式
基本介绍
1) 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。
2) 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)。
3) 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。
使用简单工厂模式
简单工厂模式的设计方案: 定义一个可以实例化 Pizaa 对象的类，封装创建对象的代码。
Pizza类不变
OrderPizza类
package com.lin.simplefactory; import java.util.Scanner;
/**
* 假如有很多orderpizza，如果增加一种pizza种类，修改就很麻烦，效率低
* @Description:
* @author LinZM
* @date 2021-2-3 0:29:26
* @version V1.8
*/
public class OrderPizza { //定义一个工厂对象
public SimpleFactory factory = null;
public Pizza pizza = null; // 构造器
public OrderPizza(SimpleFactory factory) {
setFactory(factory);
}
public void setFactory(SimpleFactory factory) {
String type = "";
this.factory = factory;
while(true) {
type = getType();
pizza = this.factory.createPizza(type); if(pizza != null) {
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} else {
System.out.println("没有这种披萨！");
break;
}
}
} public String getType() { Scanner str = new Scanner(System.in);
System.out.println("please input the type of ordered pizza:");
String type = str.next();
return type;
}
}
增加一个类--SimpleFatcory类
package com.lin.simplefactory;
/**
* 简单工厂模式
* @Description:
* @author LinZM
* @date 2021-2-3 0:28:04
* @version V1.8
*/
public class SimpleFactory { public Pizza createPizza(String orderType) {
Pizza pizza = null; System.out.println("使用简单工厂模式");
if(orderType.equals("chess")) {
pizza = new ChessPizza();
pizza.setName("chesspizza");
} else if(orderType.equals("greek")) {
pizza = new ChessPizza();
pizza.setName("greekpizza");
} else if(orderType.equals("china")) {
pizza = new ChessPizza();
pizza.setName("chinapizza");
}
return pizza;
}
}
PizzaStore类
package com.lin.simplefactory;
public class PizzaStore {
public static void main(String[] args) {
// new OrderPizza();
new OrderPizza(new SimpleFactory());
}
}
同时，简单工厂模式又叫静态工厂模式，在OrderPizza类中将creatPizza改为static，在后面使用类.方法名方式调用该方法。
仅供参考，有错误还请指出！
有什么想法，评论区留言，互相指教指教。