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

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

首先我們創建父類Cup，所有杯子類的父類。再創建它的子類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水");
    }
}

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

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水

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

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

首先我們創建抽象類Tableware，代表所有餐具的父類，再創建一個抽象工廠類TablewareFactory，抽象工廠里面有抽象方法makeTableware來制造餐具。然后我們創建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水");
    }
}

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

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飯

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

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

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

然后我們創建餐具的抽象父類Tableware和事物的抽象父類Food，再創建它們的子類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("牛奶");
    }
}

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

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();
    }
}

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

   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的小杯子
牛奶

總結：

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

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

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