案例
先看一个具体的案例:有一间披萨商店,要求完成披萨店订购功能要求考虑:
- 披萨的种类很多(比如 GreekPizz、CheesePizz等)。
- 披萨的制作有 prepare、bake、 cut,、box 等步骤。
- 要便于披萨种类的扩展,要便于维护。
传统方法
先不考虑工厂模式,要是往常我们会怎么做?可以把Pizz当成一个抽象类,里边有共用披萨的制作方法,然后让GreekPizz、CheesePizz等披萨来继承,各自实现自己需要的方法即可。先画一个xml图:
如图共有5个类,一个是抽象类Pizza,提供各种披萨的制作方法,然后两种披萨GreekPizz、CheesePizz继承该抽象类,接着一个OrderPizza类用来订购各种披萨,PizzaStore类用来向OrderPizza发出订购任务。
代码实现:
Pizza类:
package factory.simplefactory.pizzastore;
abstract public class Pizza {
private String name;
// 不同的pizza准备原材料不一样,所以做成抽象方法
public abstract void prepare();
// 烘烤
public void bake() {
System.out.println(name + " bake");
}
// 切割
public void cut() {
System.out.println(name + " cut");
}
// 打包
public void box() {
System.out.println(name + " box");
}
public void setName(String name) {
this.name = name;
}
}
GreekPizz类:
package factory.simplefactory.pizzastore;
public class GreekPizz extends Pizza {
@Override
public void prepare() {
System.out.println("给GreekPizz准备原材料");
}
}
CheesePizz类:
package factory.simplefactory.pizzastore;
public class CheesePizz extends Pizza {
@Override
public void prepare() {
System.out.println("给CheesePizz准备原材料");
}
}
OrderPizz类:
package factory.simplefactory.order;
import factory.simplefactory.pizzastore.CheesePizz;
import factory.simplefactory.pizzastore.GreekPizz;
import factory.simplefactory.pizzastore.Pizza;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
// 订购披萨
public class OrderPizz {
// 构造器
public OrderPizz() {
Pizza pizza = null;
String orderType;
do {
orderType = getype();
if (orderType.equals("greek")) {
pizza = new GreekPizz();
pizza.setName("greek");
} else if (orderType.equals("cheese")) {
pizza = new CheesePizz();
pizza.setName("cheese");
} else {
break;
}
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.bake();
} while (true);
}
// 写一个方法获取顾客订购的pizzTa种类
private String getype() {
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 "";
}
}
}
PizzaStore类:
package factory.simplefactory;
import factory.simplefactory.order.OrderPizz;
// 披萨店,相当于一个客户端,发出订购任务
public class PizzaStore {
public static void main(String[] args) {
new OrderPizz();
}
}
传统方法的缺点:违反了设计模式的ocp原则,即对扩展开放,对修改关闭。即当我们给类增加新功能的时候,尽量不修改代码,或者尽可能少修改代码。
假如我们这时要新增加一个Pizza的种类(Pepper披萨),我们需要做如下修改:
- 新增一个PepperPizza类,继承抽象类Pizza:
package factory.simplefactory.pizzastore;
public class PepperPizza extends Pizza {
@Override
public void prepare() {
System.out.println("给PepperPizza准备原材料");
}
}
- 然后还要在OrderPizz类中添加代码:
do {
orderType = getype();
if (orderType.equals("greek")) {
pizza = new GreekPizz();
pizza.setName("greek");
} else if (orderType.equals("cheese")) {
pizza = new CheesePizz();
pizza.setName("cheese");
}else if (orderType.equals("pepper")) {
pizza = new PepperPizza();
pizza.setName("pepper");
}else {
break;
}
修改代码可以接受,但是如果我们在其它的地方也有创建Pizza的代码,就意味着,也需要修改,而创建Pizza的代码,往往有多处,就像下图有很多个OrderPizz一样,那么就要进行大量的修改:
改进方法:把创建Pizza对象的功能封装到一个类中,这样我们有新的Pizza种类时,只需要修改该类就可,其它有创建到Pizza对象的代码就不需要修改了,这就是简单工厂模式。
简单工厂模式
基本介绍
- 简单工厂模式是属于创建型模式,是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。
- 简单工厂模式:定义一个创建对象的类,由这个类来封装实例化对象。
- 在软件开发中,当我们会用到大量的创建某种、某类或者某批对象时,就会使用到工厂模式。
案例改进
前面说到改进的方法是把创建Pizza对象的功能封装到一个新的类(简单工厂)中,这样OrderPizz在订购Pizza的时候就不用再去找各种Pizza了,而是之间找这个简单工厂来取即可:
- 创建一个简单工厂类SimpleFactory,把创建Pizza对象的功能写到方法createPizza()中:
package factory.simplefactory.order;
import factory.simplefactory.pizzastore.CheesePizz;
import factory.simplefactory.pizzastore.GreekPizz;
import factory.simplefactory.pizzastore.PepperPizza;
import factory.simplefactory.pizzastore.Pizza;
// 简单工厂类
public class SimpleFactory {
public Pizza createPizza(String orderType){
Pizza pizza = null;
System.out.println("使用简单工厂模式订购Pizza");
if (orderType.equals("greek")) {
pizza = new GreekPizz();
pizza.setName("greek");
} else if (orderType.equals("cheese")) {
pizza = new CheesePizz();
pizza.setName("cheese");
}else if (orderType.equals("pepper")) {
pizza = new PepperPizza();
pizza.setName("pepper");
}else {
System.out.println("输入错误");
}
return pizza;
}
}
- 然后对OrderPizz类进行修改:
package factory.simplefactory.order;
import factory.simplefactory.pizzastore.Pizza;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
// 订购披萨
public class OrderPizz {
// 构造器
public OrderPizz(SimpleFactory simpleFactory) {
setFactory(simpleFactory);
}
// 定义一个简单工厂对象
SimpleFactory simpleFactory = null;
Pizza pizza = null;
public void setFactory(SimpleFactory simpleFactory){
String orderType = " ";
this.simpleFactory = simpleFactory;
do {
orderType = getype();
pizza = this.simpleFactory.createPizza(orderType);
if (pizza != null){
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.bake();
}else {
System.out.println("订购失败");
break;
}
}while (true);
}
// 写一个方法获取顾客订购的pizzTa种类
private String getype() {
try {
BufferedReader string = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza type:");
String str = string.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
测试:
简单工厂模式的另外一种写法(静态工厂模式)
修改方法就是把SimpleFactory类的createPizza()方法设为静态的:
// 简单工厂模式也叫静态工厂模式
public static Pizza createPizza2(String orderType){
Pizza pizza = null;
System.out.println("使用简单工厂模式订购Pizza");
if (orderType.equals("greek")) {
pizza = new GreekPizz();
pizza.setName("greek");
} else if (orderType.equals("cheese")) {
pizza = new CheesePizz();
pizza.setName("cheese");
}else if (orderType.equals("pepper")) {
pizza = new PepperPizza();
pizza.setName("pepper");
}else {
System.out.println("输入错误");
}
return pizza;
}
然后修改一下OrderPizza:
package factory.simplefactory.order;
import factory.simplefactory.pizzastore.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 = getype();
pizza = SimpleFactory.createPizza2(orderType);
if (pizza != null){
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.bake();
}else {
System.out.println("订购失败");
break;
}
}while (true);
}
// 写一个方法获取顾客订购的pizzTa种类
private String getype() {
try {
BufferedReader string = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza type:");
String str = string.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
案例新需求
披萨项目新的需求:客户在点披萨时,可以点不同口味的披萨,比如 北京的奶酪pizza、北京的胡椒pizza 或者是伦敦的奶酪pizza、伦敦的胡椒pizza。
- 思路①:使用简单工厂模式,创建不同的简单工厂类,比如BJPizzaSimpleFactory、LDPizzaSimpleFactory 等等。从当前这个案例来说,是可以的,但是考虑到项目的规模,以及软件的可维护性、可扩展性并不是特别好。
- 思路②:使用工厂方法模式。
工厂方法模式
基本介绍
定义一个创建对象的抽象方法,由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。
案例改进
根据工厂方法模式,就是将披萨项目的实例化功能抽象成抽象方法,在不同的口味点餐子类中具体实现:
Pizza类:
package factory.factorymethod.pizza;
abstract public class Pizza {
private String name;
// 不同的pizza准备原材料不一样,所以做成抽象方法
public abstract void prepare();
// 烘烤
public void bake() {
System.out.println(name + " bake");
}
// 切割
public void cut() {
System.out.println(name + " cut");
}
// 打包
public void box() {
System.out.println(name + " box");
}
public void setName(String name) {
this.name = name;
}
}
BJCheesePizza;
package factory.factorymethod.pizza;
public class BJCheesePizza extends Pizza {
@Override
public void prepare() {
System.out.println("给北京的CheesePizza准备原材料");
setName("北京CheesePizza");
}
}
BJPepperPizza:
package factory.factorymethod.pizza;
public class BJPepperPizza extends Pizza {
@Override
public void prepare() {
System.out.println("给北京的PepperPizza准备原材料");
setName("北京PepperPizza");
}
}
LDCheesePizza;
package factory.factorymethod.pizza;
public class LDCheesePizza extends Pizza {
@Override
public void prepare() {
System.out.println("给伦敦的CheesePizza准备原材料");
setName("伦敦CheesePizza");
}
}
LDPepperPizza:
package factory.factorymethod.pizza;
public class LDPepperPizza extends Pizza {
@Override
public void prepare() {
System.out.println("给伦敦的PepperPizza准备原材料");
setName("伦敦PepperPizza");
}
}
OrderPizz:
package factory.factorymethod.order;
import factory.factorymethod.pizza.Pizza;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
// 订购披萨
public abstract class OrderPizz {
// 定义一个抽象方法,createPizza,让各个子类工厂自己实现
abstract Pizza createPizza(String orderType);
// 构造器
public OrderPizz() {
Pizza pizza = null;
String orderType;
do {
orderType = getype();
pizza = createPizza(orderType); // 抽象方法,由子类完成
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.bake();
} while (true);
}
// 写一个方法获取顾客订购的pizzTa种类
private String getype() {
try {
BufferedReader string = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza type:");
String str = string.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
BJOrderPizza:
package factory.factorymethod.order;
import factory.factorymethod.pizza.BJCheesePizza;
import factory.factorymethod.pizza.BJPepperPizza;
import factory.factorymethod.pizza.Pizza;
public class BJOrderPizza extends OrderPizz{
@Override
Pizza createPizza(String orderType) {
Pizza pizza = null;
if (orderType.equals("cheese")){
pizza = new BJCheesePizza();
}else if (orderType.equals("pepper")){
pizza = new BJPepperPizza();
}
return pizza;
}
}
LDOrderPizza:
package factory.factorymethod.order;
import factory.factorymethod.pizza.LDCheesePizza;
import factory.factorymethod.pizza.LDPepperPizza;
import factory.factorymethod.pizza.Pizza;
public class LDOrderPizza extends OrderPizz{
@Override
Pizza createPizza(String orderType) {
Pizza pizza = null;
if (orderType.equals("cheese")){
pizza = new LDCheesePizza();
}else if (orderType.equals("pepper")){
pizza = new LDPepperPizza();
}
return pizza;
}
}
pizzastore:
package factory.factorymethod;
import factory.factorymethod.order.BJOrderPizza;
import factory.factorymethod.order.LDOrderPizza;
import java.util.Scanner;
public class pizzastore {
public static void main(String[] args) {
System.out.println("请选择地方口味:北京/伦敦");
Scanner scan = new Scanner(System.in);
String local = " ";
local = scan.nextLine();
if (local.equals("北京")){
// 创建北京的各种口味披萨
new BJOrderPizza();
}else if (local.equals("伦敦")){
// 创建伦敦的各种口味披萨
new LDOrderPizza();
}else {
System.out.println("输入错误");
}
}
}
测试:
抽象工厂模式
基本介绍
- 抽象工厂模式:定义了一个interface用于创建相关或有依赖关系的对象簇,而无需指明具体的类。
- 从设计层面看,抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
- 将工厂抽象成两层,AbsFactory(抽象工厂) 和 具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇,更利于代码的维护和扩展。
实例改进
几个Pizza都和之前一样,就不重复写了,AbsFactory:
package factory.absfactory.order;
import factory.absfactory.pizza.Pizza;
// 抽象工厂模式的抽象层
public interface AbsFactory {
// 让工厂子类来具体实现
public Pizza createPizza(String orderType);
}
BJFactory实现AbsFactory:
package factory.absfactory.order;
import factory.absfactory.pizza.BJCheesePizza;
import factory.absfactory.pizza.BJPepperPizza;
import factory.absfactory.pizza.Pizza;
public class BJFactory implements AbsFactory {
@Override
public Pizza createPizza(String orderType) {
Pizza pizza = null;
if (orderType.equals("cheese")){
pizza = new BJCheesePizza();
}else if (orderType.equals("pepper")){
pizza = new BJPepperPizza();
}
return pizza;
}
}
LDFactory实现AbsFactory:
package factory.absfactory.order;
import factory.absfactory.pizza.LDCheesePizza;
import factory.absfactory.pizza.LDPepperPizza;
import factory.absfactory.pizza.Pizza;
public class LDFactory implements AbsFactory {
@Override
public Pizza createPizza(String orderType) {
Pizza pizza = null;
if (orderType.equals("cheese")){
pizza = new LDCheesePizza();
}else if (orderType.equals("pepper")){
pizza = new LDPepperPizza();
}
return pizza;
}
}
OrderPizza:
package factory.absfactory.order;
import factory.absfactory.pizza.Pizza;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class OrderPizza {
AbsFactory factory;
public OrderPizza(AbsFactory factory) {
setFactory(factory);
}
private void setFactory(AbsFactory factory) {
Pizza pizza = null;
String orderType = " ";
this.factory = factory;
do {
orderType = getype();
pizza = factory.createPizza(orderType);
if (pizza != null) {
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} else {
System.out.println("订购失败");
break;
}
} while (true);
}
private String getype() {
try {
BufferedReader string = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza type:");
String str = string.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
pizzastore:
package factory.absfactory;
import factory.absfactory.order.BJFactory;
import factory.absfactory.order.OrderPizza;
public class pizzastore {
public static void main(String[] args) {
new OrderPizza(new BJFactory());
// new OrderPizza(new LDFactory());
}
}