摘要：參考文章深入理解三種工廠模式工廠模式，工廠方法模式，抽象工廠模式詳解工廠模式是中最常用的設計模式之一。這種類型的設計模式屬于創(chuàng)建型模式，它提供了一種創(chuàng)建對象的最佳方式。

參考文章：
深入理解java三種工廠模式
工廠模式，工廠方法模式，抽象工廠模式 詳解

工廠模式（Factory Pattern）是 Java 中最常用的設計模式之一。這種類型的設計模式屬于創(chuàng)建型模式，它提供了一種創(chuàng)建對象的最佳方式。
在工廠模式中，我們在創(chuàng)建對象時不會對客戶端暴露創(chuàng)建邏輯，并且是通過使用一個共同的接口來指向新創(chuàng)建的對象。

工廠模式根據(jù)工廠抽象級別分為三種：
1、簡單工廠模式
2、工廠方法模式
3、抽象工廠模式

工廠模式的角色一般有以下幾個：
1、抽象工廠類（注：簡單工廠無此類）
2、具體工廠類
3、抽象產(chǎn)品類
4、具體產(chǎn)品類

class BMW {
    drive() {
        console.log("drive bmw...");
    }
}
class Benz {
    drive() {
        console.log("drive Benz...");
    }
}
class Factory {
    getBMWCar() {
        return new BMW();
    }
    getBenzCar() {
        return new Benz();
    }
}

var f1 = new Factory();
f1.getBMWCar().drive();
f1.getBenzCar().drive();

當需要添加一類產(chǎn)品時，需要在工廠里添加對應的生產(chǎn)邏輯，違背了開閉原則，簡單工廠模式只在非常簡單的情況下使用。

由于簡單工廠的弊端明顯，更多時候使用到的是工廠方法模式，工廠方法模式把生產(chǎn)過程下放到派生類，所以當添加一類產(chǎn)品的時候只需添加一個工廠，擴展性增強。

注：由于JS沒有接口也沒有抽象類的說法，用以下的形式模擬。

class FactoryInterface {
    constructor() {
        if (Object.getPrototypeOf(this) === FactoryInterface.prototype) {
            throw new Error("該類是抽象類，無法實例化")
        }
    }
    getCar() {
        throw new Error("派生類必須實現(xiàn)該方法，抽象函數(shù)無法直接調(diào)用！");
    }
}   
class BMWFactory extends FactoryInterface {
    getCar() {
        return new BMW();
    }
}
class BenzFactory extends FactoryInterface {
    getCar() {
        return new Benz();
    }
}
var bmwF = new BMWFactory();
var benzF = new BenzFactory();
bmwF.getCar().drive();
benzF.getCar().drive();

抽象工廠模式的用意為：給客戶端提供一個接口，可以創(chuàng)建多個產(chǎn)品族中的產(chǎn)品對象。而且使用抽象工廠模式還要滿足以下條件：
1.系統(tǒng)中有多個產(chǎn)品族，而系統(tǒng)一次只可能消費其中一族產(chǎn)品
2.同屬于同一個產(chǎn)品族的產(chǎn)品以其使用。
舉個例子，寶馬和奔馳兩個牌子都有越野車和商務車，寶馬系的是一個產(chǎn)品族，奔馳系的也是一個產(chǎn)品族，每個產(chǎn)品族下面都有相類似的產(chǎn)品。

class SportsCar {
    constructor() {
        if (Object.getPrototypeOf(this) === SportsCar.prototype) {
            throw new Error("該類是抽象類，無法實例化")
        }
    }
    crossCountry() {
        throw new Error("派生類必須實現(xiàn)該方法，抽象函數(shù)無法直接調(diào)用！");
    }
}
class BussinessCar {
    constructor() {
        if (Object.getPrototypeOf(this) === BussinessCar.prototype) {
            throw new Error("該類是抽象類，無法實例化")
        }
    }
    talkBusiness() {
        throw new Error("派生類必須實現(xiàn)該方法，抽象函數(shù)無法直接調(diào)用！");
    }
}
class BMWSportsCar extends SportsCar {
    crossCountry() {
        console.log("寶馬去越野");
    }
}
class BenzSportsCar extends SportsCar {
    crossCountry() {
        console.log("奔馳去越野");
    }
}
class BMWBussinessCar extends BussinessCar {
    talkBusiness() {
        console.log("寶馬去談生意");
    }
}
class BenzBussinessCar extends BussinessCar {
    talkBusiness() {
        console.log("奔馳去談生意");
    }
}
class AbstractFactory {
    constructor() {
        if (Object.getPrototypeOf(this) === AbstractFactory.prototype) {
            throw new Error("該類是抽象類，無法實例化")
        }
    }
    getSportsCar() {
        throw new Error("派生類必須實現(xiàn)該方法，抽象函數(shù)無法直接調(diào)用！");
    }
    getBussinessCar() {
        throw new Error("派生類必須實現(xiàn)該方法，抽象函數(shù)無法直接調(diào)用！");
    }
}

class BMWSoleFactory extends AbstractFactory {
    getSportsCar() {
        return new BMWSportsCar();
    }
    getBussinessCar() {
        return new BMWBussinessCar();
    }
}
class BenzSoleFactory extends AbstractFactory {
    getSportsCar() {
        return new BenzSportsCar();
    }
    getBussinessCar() {
        return new BenzBussinessCar();
    }
}

var benf2 = new BenzSoleFactory();
var bmwf2 = new BMWSoleFactory();
benf2.getSportsCar().crossCountry();
benf2.getBussinessCar().talkBusiness();
bmwf2.getSportsCar().crossCountry();
bmwf2.getBussinessCar().talkBusiness();

小結：
工廠模式的作用是解耦了產(chǎn)品的生產(chǎn)和使用部分，讓使用需要的產(chǎn)品的時候只需要調(diào)用對應的接口即可，減少冗余代碼。
優(yōu)點：1、隱藏了生產(chǎn)過程，只需調(diào)用相應接口；2、擴展性好，當需要添加一類產(chǎn)品時，只需添加對應工廠類即可。
與建造者模式區(qū)別：工廠模式不需要客戶端關心構建過程，只需要了解產(chǎn)品對應的工廠即可；建造者模式更多的是構建擁有復雜的內(nèi)部結構的對象，過程由Derector控制。