摘要：主要詳解簡單工廠模式到抽象工廠模式的演變。抽象工廠模式當一個類別的產品還有多個系列區分時，為了按系列生產商品，使用抽象工廠區分。

主要詳解簡單工廠模式到抽象工廠模式的演變。

即靜態工廠模式
1.將對象的創建和使用分開;
2.將生產過程集中，便于集中管理;
3.當需要創建的對象類有變動時，就不用在所有new 的地方修改了，直接修改工廠類即可;

/**
 * 簡單工廠模式 --- 靜態工廠模式
 */
public class StaticFactory {
    public static final int TYPE_APPLE = 1;//蘋果
    public static final int TYPE_ORANGE = 2;//桔子
    public static final int TYPE_BANANA = 3;//香蕉

    public static Fruit getFruit(int type){
        if(TYPE_APPLE == type){
            return new Apple();
        } else if(TYPE_ORANGE == type){
           return new Orange("Peter",80);
        } else if(TYPE_BANANA == type){
            return new Banana();
        }
        return null;
    }

    /**
     * 多方法工廠
     * @return
     */
    public static Fruit getFruitApple(){
        return new Apple();
    }

    public static Fruit getFruitOrange(){
        return new Orange("Peter",80);
    }

    public static Fruit getFruitBanana(){
        return new Banana();
    }


}

總的來說，簡單工廠模式就是用一個專業類（工廠類）來負責一種產品(水果類)的對象創建

簡單工廠模式不屬于23種設計模式，是工廠模式的基礎.

思考？若工廠生產的產品越來越多,靜態工廠不斷修改，方法擴展極為龐大，產品品種擴展不優雅.

1.不符合單一職責原則:一個類負責了各類水果的創建.

2.不符合開閉原則：擴展品種時，需要修改已有代碼，修改工廠類.

為了解決靜態工廠的問題，我們采用工廠方法模式

1.將靜態工廠打散，每一個水果品類，對應一個水果品類工廠來生產。

2.當需要擴展水果品類時，對應擴展一個水果品種的工廠即可。

將工廠類抽象出一個接口，對象的創建方法延遲到工廠子類去實現.

/**
 * 工廠方法接口
 */
public interface FruitFactory {
    public Fruit getFruit();//摘水果指令
}

/**
 * 橘子工廠子類
 */
public class OrangeFactory implements FruitFactory{
    public Fruit getFruit(){
        return new Orange("Peter",80);
    }
}


 /**
 * 香蕉工廠子類
 */
public class BananaFactory implements FruitFactory{
    public Fruit getFruit(){
        return new Banana();
    }
}
/**
 * 蘋果工廠子類
 */
public class AppleFactory implements FruitFactory{
    public Fruit getFruit(){
        return new Apple();
    }
}

 /**
 * 水果獲取測試
 *
 */
public class FruitTest {

    private static FruitFactory fruitFactory;

    public static void main(String[] args) {
        getFruit();
    }

    /**
     * 獲得水果
     */
    public static void getFruit(){
        //初始化蘋果工廠
        fruitFactory = new AppleFactory();
        Fruit fruit = fruitFactory.getFruit();
        fruit.draw();

        //初始化香蕉工廠
        fruitFactory = new BananaFactory ();
        Fruit bananafruit = fruitFactory.getFruit();
        bananafruit.draw();
        //想要獲取什么水果就實例化哪個工廠

    }
}

通過工廠方法模式，解決了單一職責和開閉原則問題。
需要具體的產品則初始化對應的工廠,在spring中經常是配置在配置文件中，

//然后注入進去，面向接口編程我們注入的是接口實現類在配置里
@Autowired
private FruitFactory fruitFactory;

業務慢慢發展，現在水果店品種增加，那我們按著工廠方法模式新增其他工廠實現類。

現在除了賣水果的服務還要提供額外服務，比如要包裝好，同樣的我們就新建一個包裝工廠接口如下BagFactory負責打包。

/**
 * 工廠方法模式
 */
public interface BagFactory {
    public Bag getBag();//打包指令
}
/**
 * 負責香蕉的打包
 */
public class BananaBagFactory implements BagFactory{
    public Bag getBag(){
        return new BananaBag();
    }
}
/**
 * 負責蘋果的打包
 */
public class AppleBagFactory implements BagFactory{
    public Bag getBag(){
        return new AppleBag();
    }
}

一個水果店的動作，就有從工廠獲取水果，然后從工廠獲取打包服務,如下：

/**
 * 水果店測試
 * Created by Peter on 10/8 008.
 */
public class FruitStoreTest {

    private static FruitFactory fruitFactory;
    private static BagFactory bagFactory;

    public static void main(String[] args) {
        pack();
    }

    /**
     * 郵寄打包
     */
    public static void pack(){
        //初始化蘋果工廠
        fruitFactory = new AppleFactory();//獵取工廠不對應
        Fruit fruit = fruitFactory.getFruit();
        fruit.draw();

        //初始化蘋果包裝工廠
        bagFactory = new BananaBagFactory();
        Bag bag = bagFactory.getBag();

        bag.pack();

        //....郵寄業務
    }   

產品類圖如下：

同樣的，要是再加一個郵寄業務，我們也是同樣的新增一個郵寄工廠。

問題？ 在實際寫代碼的時候是否會發生這種問題： 即獵取工廠不對應

1.初始化蘋果工廠獲取蘋果

2.初始化香蕉工廠來做包裝業務

3.初始化別的郵寄工廠來做郵寄服務

針對上面的問題就要用到我們的抽象工廠模式了。

抽象工廠模式：當一個類別的產品還有多個系列區分時，為了按系列生產商品，使用抽象工廠區分。
比如不同水果有不同包裝規格，客戶下單時，自動配出包裝，

--生產蘋果，配置紙箱包裝

--生產香蕉時，配置竹蘿包裝

PS:保證客戶端只使用同一個產品族中的對象（如下代碼的AppleFactory，BananaFactory）。

/**
 * 抽象水果工廠
 */
public abstract class AbstractFactory {

    public abstract  Fruit getFruit();

    public abstract Bag getBag();

}


/**
 * 水果工廠
 */
public class AppleFactory extends AbstractFactory{

    @Override
    public Fruit getFruit() {
        return new Apple();
    }

    @Override
    public Bag getBag() {
        return new AppleBag();
    }
}

/**
 * 水果工廠
 */
public class BananaFactory extends AbstractFactory{

    @Override
    public Fruit getFruit() {
        return new Banana();
    }

    @Override
    public Bag getBag() {
        return new BananaBag();
    }
}

/**
 * 抽象工廠模式測試
 * 按訂單發送貨品給客戶
 * Created by Peter on 10/8 008.
 */
public class OrderSendClient {
    public static void main(String[] args){
        sendFruit();
    }

    public static void sendFruit(){
        //初始化工廠
        AbstractFactory factory = new AppleFactory();//spring使用注入方式

        //得到水果
        Fruit fruit = factory.getFruit();
        fruit.draw();
        //得到包裝
        Bag bag = factory.getBag();
        bag.pack();
        //以下物流運輸業務。。。。

    }

}

抽象工廠模式類圖：

代碼地址：https://github.com/lovemumu/F...