JAVA設計模式之工廠模式

1.工廠模式簡介

工廠模式用於對象的建立，使得客戶從具體的產品對象中被解耦。

 

2.工廠模式分類

這裏以製造coffee的例子開始工廠模式設計之旅。

咱們知道coffee只是一種泛舉，在點購咖啡時須要指定具體的咖啡種類：美式咖啡、卡布奇諾、拿鐵等等。

/**
 * 
 * 拿鐵、美式咖啡、卡布奇諾等均爲咖啡家族的一種產品
 * 咖啡則做爲一種抽象概念
 * @author Lsj
 *
 */
public abstract class Coffee {

    /**
     * 獲取coffee名稱
     * @return
     */
    public abstract String getName();
    
}


/**
 * 美式咖啡
 * @author Lsj
 *
 */
public class Americano extends Coffee {

    @Override
    public String getName() {
        return "美式咖啡";
    }

}


/**
 * 卡布奇諾
 * @author Lsj
 *
 */
public class Cappuccino extends Coffee {

    @Override
    public String getName() {
        return "卡布奇諾";
    }

}


/**
 * 拿鐵
 * @author Lsj
 *
 */
public class Latte extends Coffee {

    @Override
    public String getName() {
        return "拿鐵";
    }

}

 

2.1 簡單工廠

簡單工廠實際不能算做一種設計模式，它引入了建立者的概念，將實例化的代碼從應用代碼中抽離，在建立者類的靜態方法中只處理建立對象的細節，後續建立的實例如需改變，只需改造建立者類便可，

但因爲使用靜態方法來獲取對象，使其不能在運行期間經過不一樣方式去動態改變建立行爲，所以存在必定侷限性。

/**
 * 簡單工廠--用於建立不一樣類型的咖啡實例
 * @author Lsj
 *
 */
public class SimpleFactory {
    
    /**
     * 經過類型獲取Coffee實例對象
     * @param type 咖啡類型
     * @return
     */
    public static Coffee createInstance(String type){
        if("americano".equals(type)){
            return new Americano();
        }else if("cappuccino".equals(type)){
            return new Cappuccino();
        }else if("latte".equals(type)){
            return new Latte();
        }else{
            throw new RuntimeException("type["+type+"]類型不可識別，沒有匹配到可實例化的對象！");
        }
    }
    
    public static void main(String[] args) {
        Coffee latte = SimpleFactory.createInstance("latte");
        System.out.println("建立的咖啡實例爲:" + latte.getName());
        Coffee cappuccino = SimpleFactory.createInstance("cappuccino");
        System.out.println("建立的咖啡實例爲:" + cappuccino.getName());
    }

}

 

2.2 工廠方法模式

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

場景延伸：不一樣地區咖啡工廠受制於環境、原料等因素的影響，製造出的咖啡種類有限。中國咖啡工廠僅能製造卡布奇諾、拿鐵，而美國咖啡工廠僅能製造美式咖啡、拿鐵。

/**
 * 定義一個抽象的咖啡工廠
 * @author Lsj
 */
public abstract class CoffeeFactory {
    
    /**
     * 生產可製造的咖啡
     * @return
     */
    public abstract Coffee[] createCoffee();

}


/**
 * 中國咖啡工廠
 * @author Lsj
 *
 */
public class ChinaCoffeeFactory extends CoffeeFactory {

    @Override
    public Coffee[] createCoffee() {
        // TODO Auto-generated method stub
        return new Coffee[]{new Cappuccino(), new Latte()};
    }

}


/**
 * 美國咖啡工廠
 * @author Lsj
 *
 */
public class AmericaCoffeeFactory extends CoffeeFactory {

    @Override
    public Coffee[] createCoffee() {
        // TODO Auto-generated method stub
        return new Coffee[]{new Americano(), new Latte()};
    }

}


/**
 * 工廠方法測試
 * @author Lsj
 *
 */
public class FactoryMethodTest {

    static void print(Coffee[] c){
        for (Coffee coffee : c) {
            System.out.println(coffee.getName());
        }
    }
    
    public static void main(String[] args) {
        CoffeeFactory chinaCoffeeFactory = new ChinaCoffeeFactory();
        Coffee[] chinaCoffees = chinaCoffeeFactory.createCoffee();
        System.out.println("中國咖啡工廠能夠生產的咖啡有：");
        print(chinaCoffees);
        CoffeeFactory americaCoffeeFactory = new AmericaCoffeeFactory();
        Coffee[] americaCoffees = americaCoffeeFactory.createCoffee();
        System.out.println("美國咖啡工廠能夠生產的咖啡有：");
        print(americaCoffees);
    }
}

 

 

2.3 抽象工廠

提供一個接口，用於建立相關或依賴對象的家族，而不須要明確指定具體類。

在上述的場景上繼續延伸：咖啡工廠作大作強，引入了新的飲品種類：茶、 碳酸飲料。中國工廠只能製造咖啡和茶，美國工廠只能製造咖啡和碳酸飲料。

若是用上述工廠方法方式，除去對應的產品實體類還須要新增2個抽象工廠（茶製造工廠、碳酸飲料製造工廠），4個具體工廠實現。隨着產品的增多，會致使類爆炸。

因此這裏引出一個概念產品家族，在此例子中，不一樣的飲品就組成咱們的飲品家族， 飲品家族開始承擔建立者的責任，負責製造不一樣的產品。

/**
 * 抽象的飲料產品家族製造工廠
 * @author Lsj
 *
 */
public interface AbstractDrinksFactory {

    /**
     * 製造咖啡
     * @return
     */
    Coffee createCoffee();
    
    /**
     * 製造茶
     * @return
     */
    Tea createTea();
    
    /**
     * 製造碳酸飲料
     * @return
     */
    Sodas createSodas();
}


/**
 * 中國飲品工廠
 * 製造咖啡與茶
 * @author Lsj
 *
 */
public class ChinaDrinksFactory implements AbstractDrinksFactory {

    @Override
    public Coffee createCoffee() {
        // TODO Auto-generated method stub
        return new Latte();
    }

    @Override
    public Tea createTea() {
        // TODO Auto-generated method stub
        return new MilkTea();
    }

    @Override
    public Sodas createSodas() {
        // TODO Auto-generated method stub
        return null;
    }

}


/**
 * 美國飲品製造工廠
 * 製造咖啡和碳酸飲料
 * @author Lsj
 *
 */
public class AmericaDrinksFactory implements AbstractDrinksFactory {

    @Override
    public Coffee createCoffee() {
        // TODO Auto-generated method stub
        return new Latte();
    }

    @Override
    public Tea createTea() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public Sodas createSodas() {
        // TODO Auto-generated method stub
        return new CocaCola();
    }

}


/**
 * 抽象工廠測試類
 * @author Lsj
 *
 */
public class AbstractFactoryTest {
    
    static void print(Drink drink){
        if(drink == null){
            System.out.println("產品：--" );
        }else{
            System.out.println("產品：" + drink.getName());
        }
    }
    
    public static void main(String[] args) {
        AbstractDrinksFactory chinaDrinksFactory = new ChinaDrinksFactory();
        Coffee coffee = chinaDrinksFactory.createCoffee();
        Tea tea = chinaDrinksFactory.createTea();
        Sodas sodas = chinaDrinksFactory.createSodas();
        System.out.println("中國飲品工廠有以下產品：");
        print(coffee);
        print(tea);
        print(sodas);
        
        AbstractDrinksFactory americaDrinksFactory = new AmericaDrinksFactory();
        coffee = americaDrinksFactory.createCoffee();
        tea = americaDrinksFactory.createTea();
        sodas = americaDrinksFactory.createSodas();
        System.out.println("美國飲品工廠有以下產品：");
        print(coffee);
        print(tea);
        print(sodas);
    }

}

 

 

 

3.總結

簡單工廠：不能算是真正意義上的設計模式，但能夠將客戶程序從具體類解耦。

工廠方法：使用繼承，把對象的建立委託給子類，由子類來實現建立方法，能夠看做是抽象工廠模式中只有單一產品的狀況。

抽象工廠：使對象的建立被實如今工廠接口所暴露出來的方法中。

工廠模式能夠幫助咱們針對抽象/接口編程，而不是針對具體類編程，在不一樣的場景下按具體狀況來使用。