工厂模式
需求:
看一个披萨的项目:要便于披萨种类的扩展,要便于维护。
- 披萨的种类很多(比如 GreekPizz、CheesePizz 等)。
- 披萨的制作有 prepare,bake, cut, box。
- 完成披萨店订购功能。
1、使用传统的方式来完成
思路分析(类图):
代码实现:
1、Pizza抽象类
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+"catting;");
}
public void box(){
System.out.println(name+"boxing;");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Pizza的子类CheesePizaa:
public class CheesePizaa extends Pizza {
@Override
public void prepare() {
System.out.println("给制作奶酪披萨准备原材料");
}
}
Pizza的子类GreekPizza:
public class GreekPizza extends Pizza {
@Override
public void prepare() {
System.out.println("给Greek披萨准备材料");
}
}
OrderPizza:
public class OrderPizza {
public OrderPizza() {
Pizza pizza = null;
String orderType; // 订购披萨的类型
do {
orderType = getType();
if (orderType.equals("greek")) {
pizza = new GreekPizza();
pizza.setName(" 希腊披萨 ");
} else if (orderType.equals("cheese")) {
pizza = new CheesePizaa();
pizza.setName(" 奶酪披萨 ");
} else {
break;
}
//输出 pizza 制作过程
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} while (true);
}
private String getType() {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizaa type:");
String str = null;
try {
str = strin.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
传统的方式的优缺点:
- 优点是比较好理解,简单易操作。
- 缺点是违反了设计模式的 ocp 原则,即对扩展开放,对修改关闭。即当我们给类增加新功能的时候,尽量不修改代码,或者尽可能少修改代码.
- 比如我们这时要新增加一个 Pizza 的种类(Pepper 披萨),我们需要做如下修改. 如果我们增加一个 Pizza 类,只要是订购 Pizza 的代码都需要修改:
do {
orderType = getType();
if (orderType.equals("greek")) {
pizza = new GreekPizza();
pizza.setName(" 希腊披萨 ");
} else if (orderType.equals("cheese")) {
pizza = new CheesePizaa();
pizza.setName(" 奶酪披萨 ");
} else if (orderType.equals("pepper")) {
pizza = new GreekPizza();
pizza.setName("胡椒披萨");
} else {
break;
}
改进的思路分析:
修改代码可以接受,但是如果我们在其它的地方也有创建 Pizza 的代码,就意味着,也需要修改,而创建 Pizza的代码,往往有多处。
思路:把创建 Pizza 对象封装到一个类中,这样我们有新的 Pizza 种类时,只需要修改该类就可,其它有创建到 Pizza对象的代码就不需要修改了.-> 简单工厂模式
2、简单工厂模式
-
简单工厂模式是属于创建型模式,是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。
-
简单工厂模式:定义了一个创建对象的类,由这个类来封装实例化对象的行为(代码)。
-
在软件开发中,当我们会用到大量的创建某种、某类或者某批对象时,就会使用到工厂模式。
SimpleFactory:
//简单工厂类:用于创建对象
public class SimpleFactory {
public static 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 CheesePizaa();
pizza.setName(" 奶酪披萨 ");
} else if (orderType.equals("pepper")) {
pizza = new GreekPizza();
pizza.setName("胡椒披萨");
}
return pizza;
}
}
OrderPizza :
public class OrderPizza {
public OrderPizza(){
String orderType = "";
orderType = getType();
//根据用户输入的披萨类型利用工厂对象对象
Pizza pizza = SimpleFactory.createPizza(orderType);
if(pizza != null) { //订购成功
pizza.prepare(); pizza.bake();
pizza.cut();
pizza.box();
} else {
System.out.println(" 订购披萨失败 ");
}
}
private String getType() {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizaa type:");
String str = null;
try {
str = strin.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
3、工厂方法模式
看一个新的需求:
披萨项目新的需求:客户在点披萨时,可以点不同口味的披萨,比如 北京的奶酪 pizza、北京的胡椒 pizza 或者是伦敦的奶酪 pizza、伦敦的胡椒 pizza。
思路 1:
使用简单工厂模式,创建不同的简单工厂类,比如 BJPizzaSimpleFactory、LDPizzaSimpleFactory 等等.从当前这个案例来说,也是可以的,但是考虑到项目的规模,以及软件的可维护性、可扩展性并不是特别好。
思路 2:
使用工厂方法模式。
工厂方法模式:
- 工厂方法模式设计方案:将披萨项目的实例化功能抽象成抽象方法,在不同的口味点餐子类中具体实现。
- 工厂方法模式:定义了一个创建对象的抽象方法,由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。
实例案例:
BJcheesePizza:
public class BJcheesePizza extends Pizza {
@Override
public void prepare() {
setName("北京的奶酪披萨");
System.out.println("北京的奶酪披萨,准备原材料");
}
}
BJPepperPizza:
public class BJPepperPizza extends Pizza {
@Override
public void prepare() {
setName("北京的胡椒披萨");
System.out.println("北京的胡椒披萨,准备原材料");
}
}
LDcheesePizza:
public class LDcheesePizza extends Pizza {
@Override
public void prepare() {
setName("伦敦的奶酪披萨");
System.out.println("伦敦的奶酪披萨,准备原材料");
}
}
LDPepperPizza:
public class LDPepperPizza extends Pizza {
@Override
public void prepare() {
setName("北京的胡椒披萨");
System.out.println("北京的胡椒披萨,准备原材料");
}
}
抽象类OrderPizza:
public abstract class OrderPizza {
//把创建对象的创建推迟到子类实现
public abstract Pizza createPizza(String orderType);
public OrderPizza(){
String orderType = "";
orderType = getType();
//根据用户输入的披萨类型利用工厂对象对象
Pizza pizza = createPizza(orderType);
if(pizza != null) { //订购成功
pizza.prepare(); pizza.bake();
pizza.cut();
pizza.box();
} else {
System.out.println(" 订购披萨失败 ");
}
}
private String getType() {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizaa type:");
String str = null;
try {
str = strin.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
子类BJOrderPizza:
public class BJOrderPizza extends OrderPizza {
@Override
public Pizza createPizza(String orderType) {
Pizza pizza = null;
if (orderType.equals("BJcheesePizza")){
pizza = new BJcheesePizza();
}else if (orderType.equals("BJPepperPizza")){
pizza = new BJPepperPizza();
}
return pizza;
}
}
子类LDOrderPizza:
public class LDOrderPizza extends OrderPizza {
@Override
public Pizza createPizza(String orderType) {
Pizza pizza = null;
if (orderType.equals("LDcheesePizza")){
pizza = new LDcheesePizza();
}else if (orderType.equals("LDPepperPizza")){
pizza = new LDPepperPizza();
}
return pizza;
}
}
4、抽象工厂模式
- 抽象工厂模式:定义了一个 interface 用于创建相关或有依赖关系的对象簇,而无需指明具体的类。
- 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
- 从设计层面看,抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
- 将工厂抽象成两层,AbsFactory(抽象工厂) 和 具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇,更利于代码的维护和扩展。
案例:
抽象工厂接口:
//抽象工厂接口
public interface AbsFactory {
Pizza createPizza(String orderType);
}
接口实现类BJFacyory:
//工厂子类
public class BJFacyory implements AbsFactory {
@Override
public Pizza createPizza(String orderType) {
Pizza pizza = null;
if (orderType.equals("BJcheesePizza")){
pizza = new BJcheesePizza();
}else if (orderType.equals("BJPepperPizza")){
pizza = new BJPepperPizza();
}
return pizza;
}
}
接口实现类LDFacyory:
//工厂子类
public class LDFacyory implements AbsFactory {
@Override
public Pizza createPizza(String orderType) {
Pizza pizza = null;
if (orderType.equals("LDcheesePizza")){
pizza = new LDcheesePizza();
}else if (orderType.equals("LDPepperPizza")){
pizza = new LDPepperPizza();
}
return pizza;
}
}
OrderPizza:
public class OrderPizza {
private AbsFactory absFactory = null;
private Pizza pizza = null;
public OrderPizza(AbsFactory absFactory) {
setAbsFactory(absFactory);
}
private void setAbsFactory(AbsFactory absFactory) {
this.absFactory = absFactory;
String orderType = "";
orderType = getType();
//根据用户输入的披萨类型利用工厂对象对象
pizza = absFactory.createPizza(orderType);
// Pizza pizza = SimpleFactory.createPizza(orderType);
if (pizza != null) { //订购成功
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} else {
System.out.println(" 订购披萨失败 ");
}
}
private String getType() {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizaa type:");
String str = null;
try {
str = strin.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}