客戶需求
/**
* 小明在北京開了一家pizza店，生意很好，此時，小強和小紅都想加盟他的pizza店，
* 分別在廣東和湖南開一家pizza店。（以后可能加盟店越來越多）
* 原料：dough, sauce, toppings,cheese（奶酪）, clam（哈蜊）,
* veggie（素食）, pepperoni（意式香腸）（以后可能還有更多）
*
* 制作流程：準備，烘烤，切割，打包
*
* 要求：1、廣東店和湖南店的口味不同，需適合當地人的口味
*
* 2、為保證披薩質量，加盟店必須與北京店制作流程一致
*
* 3、必須防止加盟店使用低價原料來增加利潤
*
* 請用代碼描述以上需求
*
*/
程序設計
1、PizzaStore是用來給客戶下訂單買pizza的，所以每個PizzaStore都會有一個orderPizza的方法，返回pizza給客戶；
2、當客戶下單后，就需要生產對應的pizza，PizzaStore不需要知道如何去創造pizza，根據客戶的需求交給對應的子類去完成；
3、當去生產滿足客戶需求的pizza時，我們都會用new來獲取這個pizza的實例對象，此時，我們需意識到，new pizza時是整個過程變化的部分，那么就需馬上想到我們之前學習策略模式時講過的設計原則：找出程序中可能需要變化之處，把它們獨立出來，不要和那些不需要變化的代碼混在一起
4、廢話不多說，代碼實現
-
Pizza，若以后還需要添加更多的原料，直接增加屬性就可以了
public abstract class Pizza { /** * 披薩名稱 */ protected String mPizzaName; /** * 面粉類型 */ protected String mPizzaDough; /** * 醬料類型 */ protected String mPizzaSauce; /** * 其他佐料 */ protected ArrayList<String> mPizzaToppings = new ArrayList<>(); public void prepare() { System.out.println("準備：" + mPizzaName); System.out.println("攪拌面粉：" + mPizzaDough); System.out.println("添加醬料：" + mPizzaSauce); for (int i = 0; i < mPizzaToppings.size(); i++) { System.out.println("其他佐料：" + mPizzaToppings.get(i)); } } /** * 不允許子類修改烘烤時間 */ public final void bake() { System.out.println("大約烘烤25分鐘"); } public void cut() { System.out.println("將披薩切成小塊三角形狀"); } /** * 不允許子類修改包裝方式 */ public final void box() { System.out.println("包裝好"); } public String getName() { return mPizzaName; } } -
PizzaStore
public abstract class PizzaStore { /** * 根據客戶需求預訂披薩 * * @param type * 披薩類型 * @return */ public Pizza orderPizza(String type) { Pizza pizza = createPizza(type); pizza.prepare(); pizza.bake(); pizza.cut(); pizza.box(); return pizza; } public abstract Pizza createPizza(String type); } -
GuangDongStylePizzaStore
public class GuangDongStylePizzaStore extends PizzaStore { @Override public Pizza createPizza(String type) { Pizza pizza = null; // 這里可以用枚舉來表示pizza的原料內容，防止客戶輸入錯誤。這里就偷一下懶了 if (type.equals("cheese")) { pizza = new GuangDongStyleCheesePizza(); } else if (type.equals("pepperoni")) { pizza = new GuangDongStylePepperoniPizza(); } else if (type.equals("clam")) { pizza = new GuangDongStyleClamPizza(); } else if (type.equals("veggie")) { pizza = new GuangDongStyleVeggiePizza(); } return pizza; } } -
HuNanStylePizzaStore
public class HuNanStylePizzaStore extends PizzaStore { @Override public Pizza createPizza(String type) { Pizza pizza = null; if (type.equals("cheese")) { pizza = new HuNanStyleCheesePizza(); } else if (type.equals("pepperoni")) { pizza = new HuNanStylePepperoniPizza(); } else if (type.equals("clam")) { pizza = new HuNanStyleClamPizza(); } else if (type.equals("veggie")) { pizza = new HuNanStyleVeggiePizza(); } return pizza; } } -
這里只貼出兩種CheesePizza的代碼
/** * 湖南口味奶酪披薩 * * */ public class HuNanStyleCheesePizza extends Pizza { public HuNanStyleCheesePizza() { mPizzaName = "HuNan Style Deep Dish Cheese Pizza"; mPizzaDough = "Extra Thick Crust Dough"; mPizzaSauce = "Plum Tomato Sauce"; mPizzaToppings.add("Shredded Mozzarella Cheese"); } @Override public void cut() { System.out.println("將披薩切成小塊矩形狀"); } } ----------------------------------------------------------- /** * 廣東口味奶酪披薩 * * */ public class GuangDongStyleCheesePizza extends Pizza { public GuangDongStyleCheesePizza() { mPizzaName = "New York Style Sauce and Cheese Pizza"; mPizzaDough = "Thin Crust Dough"; mPizzaSauce = "Marinara Sauce"; mPizzaToppings.add("Grated Reggiano Cheese"); } }
測試代碼
public class FactoryDesignPatternTest
{
public static void main(String[] args)
{
PizzaStore huNanPizzaStore = new HuNanStylePizzaStore();
PizzaStore guangDongPizzaStore = new GuangDongStylePizzaStore();
Pizza huNanPizza = huNanPizzaStore.orderPizza("cheese");
System.out.println(huNanPizza.getName());
System.out.println("-----------------------------------");
Pizza guangDongPizza = guangDongPizzaStore.orderPizza("cheese");
System.out.println(guangDongPizza.getName());
}
}
測試結果
FactoryMethodPatternTest.png
工廠方法模式
-
定義
定義了一個創建對象的抽象類，但由子類決定要實例化的類是哪一個。工廠方法讓類把實例化推遲到子類
Demo UML圖
FactoryMethodPatternDemoUML.png
接下來，我們為每個區域創建原料工廠
public interface PizzaIngredientFactory
{
/*
* 創建原料的方法，為了方便，直接用字符串代替， 在實際項目中，原料可以用類來表示
*/
public String createDough();
public String createSauce();
public String createCheese();
public String[] createVeggies();
public String createPepperoni();
public String createClams();
}
不同區域有不同的原料工廠
public class HuNanPizzaIngredientFactory implements PizzaIngredientFactory
{
@Override
public String createDough()
{
return "ThinCrustDough";
}
@Override
public String createSauce()
{
return "MarinaraSauce";
}
@Override
public String createCheese()
{
return "ReggianoCheese";
}
@Override
public String[] createVeggies()
{
return new String[] { "Garlic", "Onion", "Mushroom", "RedPepper" };
}
@Override
public String createPepperoni()
{
return "SlicedPepperoni";
}
@Override
public String createClams()
{
return "FreshClams";
}
}
----------------------------------------------------------------------
public class GuangDongPizzaIngredientFactory implements PizzaIngredientFactory
{
@Override
public String createDough()
{
return "ThickCrustDough";
}
@Override
public String createSauce()
{
return "PlumTomatoSauce";
}
@Override
public String createCheese()
{
return "MozzarellaCheese";
}
@Override
public String[] createVeggies()
{
return new String[] { "BlackOlives", "Spinach", "Eggplant" };
}
@Override
public String createPepperoni()
{
return "SlicedPepperoni";
}
@Override
public String createClams()
{
return "FrozenClams";
}
}
重新修改一下pizza的代碼，添加兩種原料，并抽象準備流程，讓子類自己去準備需要的原料
public abstract class Pizza
{
protected String mPizzaName;
protected String mPizzaDough;
protected String mPizzaSauce;
protected ArrayList<String> mPizzaToppings = new ArrayList<>();
//新添加的原料
protected String mPizzaCheese;
protected String mPizzaClam;
// public void prepare()
// {
// System.out.println("準備：" + mPizzaName);
// System.out.println("攪拌面粉：" + mPizzaDough);
// System.out.println("添加醬料：" + mPizzaSauce);
// for (int i = 0; i < mPizzaToppings.size(); i++)
// {
// System.out.println("其他佐料：" + mPizzaToppings.get(i));
// }
//}
protected abstract void prepareIngredient();
public final void bake()
{
System.out.println("大約烘烤25分鐘");
}
public void cut()
{
System.out.println("將披薩切成小塊三角形狀");
}
public final void box()
{
System.out.println("包裝好");
}
public void setName(String name)
{
mPizzaName = name;
}
public String getName()
{
return mPizzaName;
}
}
我們不需要設計不同的類來處理不同口味的披薩，讓原料廠處理這種區域差異就可以了。
public class CheesePizza extends Pizza
{
private PizzaIngredientFactory mIngredientFactory;
public CheesePizza(PizzaIngredientFactory factory) {
mIngredientFactory = factory;
}
@Override
protected void prepareIngredient()
{
System.out.println("preparing:" + mPizzaName);
mPizzaDough = mIngredientFactory.createDough();
mPizzaSauce = mIngredientFactory.createSauce();
mPizzaCheese = mIngredientFactory.createCheese();
}
}
再回我到我們的Pizza店
public class HuNanStylePizzaStore extends PizzaStore
{
@Override
public Pizza createPizza(String type)
{
Pizza pizza = null;
// 湖南Pizza店用到了湖南原料工廠，由該原料工廠負責生產所有湖南口味的披薩所需的原料
PizzaIngredientFactory ingredientFactory = new HuNanPizzaIngredientFactory();
if (type.equals("cheese"))
{
// 對象組合：把工廠傳遞給每一個披薩，以便披薩從工廠中取得原料
pizza = new CheesePizza(ingredientFactory);
pizza.setName("New York Style Cheese Pizza");
}
else if (type.equals("pepperoni"))
{
pizza = new PepperoniPizza(ingredientFactory);
pizza.setName("New York Style Pepperoni Pizza");
}
else if (type.equals("clam"))
{
pizza = new ClamPizza(ingredientFactory);
pizza.setName("New York Style Clam Pizza");
}
else if (type.equals("veggie"))
{
pizza = new VeggiePizza(ingredientFactory);
pizza.setName("New York Style Veggie Pizza");
}
return pizza;
}
}
測試代碼
PizzaStore NYStore = new NYStylePizzaStore();
Pizza pizzaTwo = NYStore.orderPizza("cheese");
System.out.println(pizzaTwo.getName());
此時，你有沒有發現這個版本的createPizza()和之前的工廠方法實現的有什么不同？
我們引入了新類型的工廠，也就是所謂的抽象工廠來創建披薩原料家族。通過抽象工廠所提供的接口，可以創建產品的家族，利用這個接口書寫代碼，我們的代碼將從實際工廠解耦，以便在不同上下文中實現各式各樣的工廠，制造出各種不同的產品。
抽象工廠模式
-
定義
提供一個接口，用于創建相關或依賴對象的家族，而不需要明確指定具體類
Demo UML類圖
AbstractFactoryPatternDemoUML.png
你可能注意到了，抽象工廠的每個方法實際上看起來都是工廠方法，因為每個方法都被聲明成抽象，而子類的方法覆蓋這些法來創建某些對象。
那么，工廠方法是不是潛伏在抽象工廠里面了？
是的，抽象工廠的方法經常以工廠方法的方式實現。抽象工廠的任務就是定義一個負責創建一組產品的接口，這個接口內的每個方法都負責創建一個具體的產品，同時我們利用實現抽象工廠的子類來提供這些具體的做法。所以，在抽象工廠中利用工廠方法實現生產方法是相當自然的做法。
工廠方法模式與抽象工廠模式不同之處
FactoryMethodPatternUML.png
AbstractFactoryPatternUML.png
- 工廠方法利用繼承的方式來創建對象，抽象工廠則是用的對象組合來創建對象
- 工廠方法只能生產同一等級結構中的固定產品，而抽象工廠能夠生產不同產品族的全部產品
- 工廠方法的優勢：支持增加任意產品；抽象工廠的優勢：支持增加產品族，對于增加新的產品，需改變接口，可能會造成繁重的工作；
工廠模式中用到的設計原則
依賴倒置原則（Dependency Inversion Principle)
要依賴抽象，不要依賴具體類
這個原則似乎聽起來很像是“針對接口編程，不針對實現編程”，的確很相似，但這里更強調“抽象”。這個原則說明了：不能讓高層組件依賴低層組件，并且，不管高層或低層組件，“兩者”都應該依賴于抽象。
在我們的Demo中，PizzaStore是“高層組件”，而具體的pizza是”低層組件“，他們都依賴Pizza這個抽象類。
