摘要：工廠模式，又稱為工廠方法模式。工廠模式，也就是工廠方法模式是解決了簡單工廠要修改代碼的問題，他把對象的創(chuàng)建操作延遲到子類工廠中，這樣新增產(chǎn)品就不需要修改代碼。

簡單工廠其實并不是設計模式，只是一種編程習慣。

首先我們創(chuàng)建父類Cup，所有杯子類的父類。再創(chuàng)建它的子類BigCup和SmallCup類。

public abstract class Cup {
    public abstract void use();
}

public class BigCup extends Cup {
    @Override
    public void use() {
        System.out.println("大杯裝500ml水");
    }
}

public class SmallCup extends Cup {
    @Override
    public void use() {
        System.out.println("小杯裝100ml水");
    }
}

然后我們創(chuàng)建工廠類CupFactory，工廠里聲明了Cup引用，根據(jù)傳入的參數(shù)type來判斷生產(chǎn)什么類型的杯子，這樣外部只需要傳入類型就可以生成想要的類型的對象，現(xiàn)在運行看一下結果，沒有問題。

public class CupFactory{
    public Cup makeCup(String type){
        Cup cup = null;
        if (type.equals("big")){
            cup = new BigCup();
        }else if (type.equals("small")){
            cup = new SmallCup();
        }
        return cup;
    }
}

public static void main(String[] args){
    CupFactory cupFactory = new CupFactory();
    Cup smallCup = cupFactory.makeCup("small");
    smallCup.use();
    Cup bigCup = cupFactory.makeCup("big");
    bigCup.use();
}

結果：
小杯裝100ml水
大杯裝500ml水

簡單工廠雖然解決了一些問題但是當我們的需要增加子類的時候就很麻煩了，需要修改工廠類里的代碼，違反了開放封閉原則，所以我們現(xiàn)在使用真正的工廠模式來解決這個問題。

工廠模式，又稱為工廠方法模式。定義了一個創(chuàng)建產(chǎn)品對象的工廠接口，將實際創(chuàng)建工作推遲到子類工廠當中。

首先我們創(chuàng)建抽象類Tableware，代表所有餐具的父類，再創(chuàng)建一個抽象工廠類TablewareFactory，抽象工廠里面有抽象方法makeTableware來制造餐具。然后我們創(chuàng)建4個餐具子類，分別是BigBowl、SmallBowl、BigCuphe和SmallCup。

public abstract class Tableware {
    public abstract void use();
}

public abstract class TableWareFactory {
    public abstract Tableware makeTableware(String type);
}

public class BigBowl extends Tableware {
    @Override
    public void use() {
        System.out.println("大碗裝500g飯");
    }
}

public class SmallBowl extends Tableware {
    @Override
    public void use() {
        System.out.println("小碗裝100g飯");
    }
}

public class BigCup extends Tableware {
    @Override
    public void use() {
        System.out.println("大杯裝500ml水");
    }
}

public class SmallCup extends Tableware {
    @Override
    public void use() {
        System.out.println("小杯裝100ml水");
    }
}

接下來我們需要實現(xiàn)工廠類了，這是最關鍵的部分，從上述4個子類可以看出，BigBowl和SmallBowl是一類產(chǎn)品，而BigCup和SamllCup是另一類，所以我們創(chuàng)建兩個子類工廠，分別是BowlFactory和CupFactory。它們生產(chǎn)不同的產(chǎn)品，但是又能根據(jù)參數(shù)來生產(chǎn)不同規(guī)格的同類產(chǎn)品。在子類工廠中的makeTableware方法才是決定生產(chǎn)什么產(chǎn)品，而父類工廠并不知道，這就是將實際創(chuàng)建工作推遲到子類工廠當中。當我們想要新建別的產(chǎn)品的時候增加新的子類工廠即可。

public class BowlFactory extends TableWareFactory {

    @Override
    public Tableware makeTableware(String type) {
        Tableware tableware = null;
        if (type.equals("big")){
            tableware = new BigBowl();
        }else if (type.equals("small")){
            tableware = new SmallBowl();
        }
        return tableware;
    }
}

public class CupFactory extends TableWareFactory {
    @Override
    public Tableware makeTableware(String type) {
        Tableware tableware = null;
        if (type.equals("big")){
            tableware = new BigCup();
        }else if (type.equals("small")){
            tableware = new SmallCup();
        }
        return tableware;
    }
}

測試一下看看結果，結果沒有問題。

TableWareFactory cupFactory = new CupFactory();
Tableware bigCup = cupFactory.makeTableware("big");
bigCup.use();
Tableware smallCup = cupFactory.makeTableware("small");
smallCup.use();
TableWareFactory bowlFactory = new BowlFactory();
Tableware bigBowl =  bowlFactory.makeTableware("big");
bigBowl.use();
Tableware smallBowl = bowlFactory.makeTableware("small");
smallBowl.use();

結果：
大杯裝500ml水
小杯裝100ml水
大碗裝500g飯
小碗裝100g飯

抽象工廠模式其實是在工廠方法模式的基礎上加入了產(chǎn)品族的概念，也就是工廠里會生產(chǎn)多種產(chǎn)品，他們需要配套使用，例如衣服和褲子。

我們先創(chuàng)建一個抽象工廠BaseFactory類，有兩個抽象方法makeTableware和getFood，分別生產(chǎn)餐具和食物，因為它們兩個是要配合使用的。

public abstract class BaseFactory {
    public abstract Tableware makeTableware();
    public abstract  Food getFood();
}

然后我們創(chuàng)建餐具的抽象父類Tableware和事物的抽象父類Food，再創(chuàng)建它們的子類BigBowl、SmallCup、Meat和Milk類。

public abstract class Tableware {
    public abstract void use();
}

public abstract class Food {
    public abstract void name();
}

public class BigBowl extends Tableware {
    @Override
    public void use() {
        System.out.println("500ml的大碗");
    }
}

public class SmallCup extends Tableware {
    @Override
    public void use() {
        System.out.println("100ml的小杯子");
    }
}

public class Meat extends Food {
    @Override
    public void name() {
        System.out.println("肉");
    }
}

public class Milk extends Food {
    @Override
    public void name() {
        System.out.println("牛奶");
    }
}

接下來我們創(chuàng)建兩個子類工廠MeatWithBowlFactory和MilkWithCupFactory
類，這兩個類把肉和碗分到一個工廠里，牛奶和杯子分到一個工廠里，表示他們需要配套使用。這里的makeTableware和getFood方法也可以像上面工廠方法模式里一樣接受參數(shù)生成不同規(guī)格的產(chǎn)品，現(xiàn)在是直接返回一個對象。

public class MeatWithBowlFactory extends BaseFactory {
    @Override
    public Tableware makeTableware() {
        return new BigBowl();
    }

    @Override
    public Food getFood() {
        return new Meat();
    }
}

public class MilkWithCupFactory extends BaseFactory{
    @Override
    public Tableware makeTableware() {
        return new SmallCup();
    }

    @Override
    public Food getFood() {
        return new Milk();
    }
}

現(xiàn)在測試一下結果，沒有問題，同一個工廠可以生產(chǎn)需要配套的產(chǎn)品。

   BaseFactory baseFactory;
   baseFactory = new MeatWithBowlFactory();
   BigBowl bigBowl = (BigBowl) baseFactory.makeTableware();
   bigBowl.use();
   Meat meat = (Meat)baseFactory.getFood();
   meat.name();

   baseFactory = new MilkWithCupFactory();
   SmallCup smallCup = (SmallCup) baseFactory.makeTableware();
   smallCup.use();
   Milk milk = (Milk)baseFactory.getFood();
   milk.name();

結果：
500ml的大碗
肉
100ml的小杯子
牛奶

總結：

簡單工廠模式其實只是把創(chuàng)建對象這個常用的工廠做成工廠類方便調(diào)用，但是修改的時候需要修改工廠的代碼，只是一種編程習慣，不是設計模式。

工廠模式，也就是工廠方法模式是解決了簡單工廠要修改代碼的問題，他把對象的創(chuàng)建操作延遲到子類工廠中，這樣新增產(chǎn)品就不需要修改代碼。

抽象工廠模式就是在工廠方法模式的基礎上加入了產(chǎn)品族的概念，如果幾個產(chǎn)品需要配套使用，就可以將他們放在同一個工廠里自行選擇搭配，比如牛肉放在瓷碗里，豬肉放在鐵碗里。