一、概述

什么是工廠模式？

工廠模式(Factory Pattern)是最常見的一種設(shè)計模式之一。它主要是提供一種創(chuàng)建對象的最佳方法！

為什么要學(xué)習(xí)工廠模式？

與通過new來創(chuàng)建對象不同，使用工廠模式創(chuàng)建對象不會對客戶端暴露創(chuàng)建邏輯，并且是通過統(tǒng)一個共同的接口指向新創(chuàng)建的對象。同事工廠模式能將創(chuàng)建對象的代碼集中在一個對象或者方法中，可以避免代碼中的重復(fù)，并且更方便維護。面向接口編程，這樣的代碼更具有彈性，可以應(yīng)對未來的擴展。

二、認識工廠模式

案例：假設(shè)你有一個Pizza店，每天要做出不同口味的Pizza。

假設(shè)我們有兩種口味Pizza

/*

* 抽象的Pizza類，Pizza制作一般包括準備，烘烤，切塊，包裝。

*/

public abstract class Pizza{

// Pizza名稱

protected String name;

// 面團類型

protected String dough;

// 醬料

protected String sauce;

// 芝士

protected String cheese;

// 蛤蜊

protected String clam;

// 佐料

protected List toppings = new ArrayList();

// 準備

public void prepare() {

System.out.print("準備食材，添加調(diào)料:");

for (int i = 0; i < toppings.size(); i++) {

System.out.print(toppings.get(i)+" ");

}

};

// 烘烤

public void bake() {

System.out.println("烘烤20分鐘...");

};

// 切塊

public void cut() {

System.out.println("切成x塊...");

};

// 包裝

public void box() {

System.out.println("包裝...");

}

// setter 和 getter方法省略

}

芝加哥風(fēng)味的芝士Pizza

public class ChicagoStyleCheesePizza extends Pizza{

public ChicagoStyleCheesePizza() {

name = "Chicago Style Deep Dish Cheese Pizza";

dough = "Extra Thick Crust Dough";

sauce = "Plum Tomato Sauce";

toppings.add("Shredded Mozzarella Cheese");

}

public void cut() {

System.out.println("Cut the pizza into square slices");

}

}

紐約風(fēng)味的蔬菜Pizza

public class NyStyleVeggiePizza extends Pizza{

public NyStyleVeggiePizza() {

name = "NY style Sauce and Veggie Pizza";

dough = "Thin Crust Dough";

sauce = "Marinara Sauce";

toppings.add("Grated Reggiano Veggie");

}

}

紐約風(fēng)味的芝士Pizza

public class NyStyleCheesePizza extends Pizza{

public NyStyleCheesePizza() {

name = "NY style Sauce and Cheese Pizza";

dough = "Thin Crust Dough";

sauce = "Marinara Sauce";

toppings.add("Grated Reggiano Cheese");

}

}

通過new創(chuàng)建對象

// 創(chuàng)建一個紐約風(fēng)味的芝士Pizza

NyStyleCheesePizza nyPizza = new NyStyleCheesePizza();

當(dāng)使用new得到一個對象時，確實得到了一個具體類，是針對具體類實現(xiàn)，而不是接口。代碼綁定具體類會導(dǎo)致代碼脆弱，更缺乏彈性。

簡單工廠

public class SimplePizzaFactory {

public Pizza createPizza(String type) {

Pizza pizza = null;

if (type.equals("NyStyleCheesePizza")) {

return new NyStyleChieesePizza();

} else if(type.endsWith("ChicagoStyleCheesePizza")) {

return new ChicagoStyleCheesePizza();

}else {

return null;

}

}

}

// 創(chuàng)建簡單工廠對象

SimplePizzaFactory pizzaFactory = new SimplePizzaFactory();

// 創(chuàng)建Pizza對象

NyStyleChieesePizza myPizza = pizzaFactory.createPizza("NYStyleChieesePizza");

簡單工廠將對象的創(chuàng)建過程進行了封裝，用戶不需要知道具體的創(chuàng)建過程，只需要調(diào)用工廠類獲取對象即可。

這種簡單工廠的寫法是通過if else來判斷對象創(chuàng)建過程的。簡單工廠只是把new對象的問題轉(zhuǎn)移到另一個類中在實際使用過程中，違背了 開放-關(guān)閉原則，當(dāng)然有些情況下可以通過反射調(diào)用來彌補這種不足。

工廠方法模式

定義：定義了一個創(chuàng)建對象的接口，但由子類決定要實例化的類是哪一個。工廠方法讓類把實例化推遲到子類。

// 抽象的Pizza工廠

public abstract class PizzaFactory {

public Pizza getPizza(String type) {

Pizza pizza;

pizza = createPizza(type);

pizza.prepare();

pizza.bake();

pizza.cut();

pizza.box();

return pizza;

}

protected abstract Pizza createPizza(String pizza);

}

// 紐約Pizza工廠(芝加哥pizza工廠跟這個類似)

public class NYPizzaFactory extends PizzaFactory {

protected Pizza createPizza(String type) {

if (type.equals("NyStyleChieesePizza")) {

return new NyStyleCheesePizza();

} else if (type.equals("NyStyleVeggiePizza")) {

return new NyStyleVeggiePizza();

}else {

return null;

}

}

}

通過工廠方法創(chuàng)建對象

PizzaFactory pizzaFactory = new NYPizzaFactory();

// 創(chuàng)建一個蔬菜披薩

Pizza pizza = pizzaFactory.createPizza("NyStyleVeggiePizza");

當(dāng)使用工廠方法創(chuàng)建對象時，是在編寫具體工廠類時決定創(chuàng)建的對象時哪一個，選擇使用哪個工廠類，自然就決定了十幾創(chuàng)建的是哪個對象。盡管只有一個具體工廠，工廠方法還是非常有用的！因為它將對象從“實現(xiàn)”從“使用”中解耦，如果增加對象或者改變對象，工廠是不會受到影響的！

抽象工廠模式

定義：提供一個接口，用于創(chuàng)建相關(guān)或依賴對象的家族，而不需要明確指定具體類。

抽象原料工廠

// 為了簡化， 這里的原料用字符串表示，其實每個原料應(yīng)該用一個類表示

public interface PizzaIngredientFactory {

public String createDough();

public String createSauce();

public String createChieese();

public String[] createVeggies();

public String createPepperoni();

}

芝士pizza原料工廠

public class CheesePizzaIngredientFactory implements PizzaIngredientFactory {

public String createDough() {

return "薄地殼比薩生面團";

}

public String createSauce() {

return "紐約專用蘸料";

}

public String createChieese() {

return "Reggiano干酪";

}

public String[] createVeggies() {

return new String[]{"洋蔥","生菜","香菇"};

}

public String createPepperoni() {

return "意大利辣香腸";

}

}

創(chuàng)建pizza工廠

public class ChinaPizzaFactory extends PizzaFactory {

public Pizza createPizza(String type) {

Pizza pizza = null;

PizzaIngredientFactory ingredientFactory = new ChinaPizzaIngredientFactory();

if(type.equals("cheese")) {

pizza = new CheesePizza(ingredientFactory);

pizza.setName("中國芝士pizza");

}else if (type.equals("clam")) {

pizza = new ClamPizza(ingredientFactory);

pizza.setName("中國蛤蜊pizza");

}

return pizza;

}

}

// 具體的Pizza類

public class ClamPizza extends Pizza {

PizzaIngredientFactory ingredientFactory;

public ClamPizza(PizzaIngredientFactory pizzaIngredientFactory) {

this.ingredientFactory = pizzaIngredientFactory;

}

public void prepare() {

System.out.println("Preparinging" + name);

// 根據(jù)pizza本身的特點，從工廠中獲取自己需要的原料

dough = ingredientFactory.createDough();

sauce = ingredientFactory.createSauce();

clam = ingredientFactory.creatClam();

}

}

創(chuàng)建一個中國蛤蜊pizza

// 創(chuàng)建一個Pizza工廠

PizzaFactory pizzaFactory = new ChinaPizzaFactory();

Pizza clamPizza = pizzaFactory.createPizza("clam");

抽象工廠模式將'對象' 與 ‘’組成對象或者對象依賴的類‘’解耦。

三、對比與分析

通過new來創(chuàng)建對象是面向具體類編程，擴展性差！

簡單工廠把全部的事情都在一個地方處理完了，但是當(dāng)有新增或者修改的對象類時，很難進行擴展，違反了開閉原則。簡單工廠并不能算是工廠模式，而是一種編程習(xí)慣，或者是一種方法的封裝，并不具備彈性。

工廠方法是創(chuàng)建一個框架，讓子類決定如何實現(xiàn)。雖然可能導(dǎo)致類會變多，代碼稍微復(fù)雜，但是這樣做最大的好處是更具有彈性。

工廠模式的好處：將創(chuàng)建對象的代碼集中在一個對象或者方法中，可以避免代碼中重復(fù)的代碼，并且方便以后的維護。依賴接口，而不是具體的類。

如何選擇？

當(dāng)需要將對象家族和具體的對象集合結(jié)合起來時，可以使用抽象工廠。

當(dāng)需要將客戶代碼從需要實例化的具體類中解耦，或者目前還不中知道將來實例化哪些具體類時，可以使用工廠方法。

總結(jié)

以上是生活随笔為你收集整理的java 工厂模式的写法_设计模式-工厂模式的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。