js經常使用設計模式實現（二）工廠模式和抽象工廠模式

建立型模式

建立型模式是對一個類的實例化過程進行了抽象，把對象的建立和對象的使用進行了分離

上一篇介紹了下單例模式，這一篇介紹一下工廠模式和抽象工廠模式，爲何把這兩個放在一塊兒說，由於我我的認爲他們兩個是有關聯的，簡單工廠模式被我看做是工廠模式的簡潔版，而後工廠模式被我看做是抽象工廠模式的簡潔版

簡單工廠

定義：簡單工廠模式中，能夠根據參數的不一樣返回不一樣類的實例。簡單工廠模式專門定義一個類來負責建立其餘類的實例，被建立的實例一般都具備共同的父類。

好比你去專門賣鼠標的地方你能夠買各類各樣的鼠標

最通俗的理解就是封裝，簡單帶過一下

function mouse(color,long){
    
    　　　　var o = new Object();
    
    　　　　o.color= color;
                              
    　　　　o.long= long; 
    
    　　　　o.Explain= function(){
    
    　　　　　　console.log(this.color，this.long);
    
    　　　　}
    
    　　　　return o;
    
    　　}
    
    var mouseA = mouse('黑色',3);

工廠模式

定義：工廠方法模式中，工廠父類負責定義建立產品對象的公共接口，而工廠子類則負責生成具體的產品對象，這樣作的目的是將產品類的實例化操做延遲到工廠子類中完成，即經過工廠子類來肯定究竟應該實例化哪個具體產品類。

好比去旁邊還有個專門賣鍵盤的和耳機的而後他和賣鼠標的組成了一個門店

你要進如這個門店而後買鼠標或者鍵盤或者耳機

你能夠把這個工廠模式理解成是 進化版的簡單工廠模式

shop= function(val) {

      if(typeof this === "object") { //看看有沒有new   沒有new的話new一個
        var s = new this[val]();
        return s;
      } else {
        return new shop(val);
      }
    }
    
    
    shop.prototype = {
      mouse: function() {
        console.log("買了個鼠標")
      },
         keyboard: function() {
        console.log("買了個鍵盤")
     }, 
        headset: function() {
        console.log("買了個耳機")
     } }
     bigShop = new shop();
     mouse = new bigshop.mouse();

抽象工廠模式

定義：抽象工廠模式是指當有多個抽象角色時，使用的一種工廠模式。抽象工廠模式能夠向客戶端提供一個接口，使客戶端在沒必要指定產品的具體的狀況下，建立多個產品族中的產品對象。

前邊的兩個都是直接生產實例的，開始覺得抽象工廠也是可是後來發現抽象工廠更像是生產工廠，其實抽象工廠實際上是實現子類繼承父類的方法。

說白了 抽象工廠模式 我認爲就是工廠功能模式的擴充版，簡單工廠生產實例 ，工廠功能模式生產實例的接口，抽象工廠呢生產的是工廠

好比說上邊他們有了個電腦店的門店 如今電腦店火了 又開了一個電腦店 而後這兩個電腦店一個是聯想的 一個是戴爾的

核心代碼
    let agency = function(subType, superType) {
      //判斷抽象工廠中是否有該抽象類
      if(typeof agency[superType] === 'function') {
        function F() {};
        //繼承父類屬性和方法
        F.prototype = new agency[superType] ();
        //將子類的constructor指向子類
        subType.constructor = subType;
        //子類原型繼承父類
        subType.prototype = new F();
    
      } else {
        throw new Error('抽象類不存在!')
      }
    }

這是建立工廠的類   比如專賣店

    //鼠標抽象類
    agency.mouseShop = function() {
      this.type = '鼠標';
    }
    agency.mouseShop.prototype = {
      getName: function() {
        return new Error('抽象方法不能調用');
      }
    }
    
    //鍵盤抽象類
    agency.KeyboardShop = function() {
      this.type = '鍵盤';
    }
    agency.KeyboardShop.prototype = {
      getName: function() {
        return new Error('抽象方法不能調用');
      }
    }

//普通鼠標子類
    function mouse(name) {
      this.name = name;
      this.item = ['買我，我線長',"玩遊戲賊溜"]
    }
    //抽象工廠實現鼠標類的繼承
    agency(mouse, 'mouseShop');
    //子類中重寫抽象方法
    mouse.prototype.getName = function() {
      return this.name;
    }
    
    //普通鍵盤子類
    function Keyboard(name) {
      this.name = name;
      this.item = ['行，你買它吧',"沒鍵盤看你咋玩"]
    }
    //抽象工廠實現鍵盤類的繼承
    agency(Keyboard, 'KeyboardShop');
    //子類中重寫抽象方法
    Keyboard.prototype.getName = function() {
      return this.name;
    }

最後放一下所有代碼

let agency = function(subType, superType) {
      //判斷抽象工廠中是否有該抽象類
      if(typeof agency[superType] === 'function') {
        function F() {};
        //繼承父類屬性和方法
        F.prototype = new agency[superType] ();
        //將子類的constructor指向子類
        subType.constructor = subType;
        //子類原型繼承父類
        subType.prototype = new F();
    
      } else {
        throw new Error('抽象類不存在!')
      }
    }
    
    //鼠標抽象類
    agency.mouseShop = function() {
      this.type = '鼠標';
    }
    agency.mouseShop.prototype = {
      getName: function() {
        return new Error('抽象方法不能調用');
      }
    }
    
    //鍵盤抽象類
    agency.KeyboardShop = function() {
      this.type = '鍵盤';
    }
    agency.KeyboardShop.prototype = {
      getName: function() {
        return new Error('抽象方法不能調用');
      }
    }
    
    
    
    //普通鼠標子類
    function mouse(name) {
      this.name = name;
      this.item = ['買我，我線長',"玩遊戲賊溜"]
    }
    //抽象工廠實現鼠標類的繼承
    agency(mouse, 'mouseShop');
    //子類中重寫抽象方法
    mouse.prototype.getName = function() {
      return this.name;
    }
    
    //普通鍵盤子類
    function Keyboard(name) {
      this.name = name;
      this.item = ['行，你買它吧',"沒鍵盤看你咋玩"]
    }
    //抽象工廠實現鍵盤類的繼承
    agency(Keyboard, 'KeyboardShop');
    //子類中重寫抽象方法
    Keyboard.prototype.getName = function() {
      return this.name;
    }
    
    
    
    //實例化鼠標
    let mouseA = new mouse('聯想');
    console.log(mouseA.getName(), mouseA.type); //聯想 鼠標
    let mouseB = new mouse('戴爾');
    console.log(mouseB.getName(), mouseB.type); //戴爾 鼠標
    
    //實例化鍵盤
    let KeyboardA = new Keyboard('聯想');
    console.log(KeyboardA.getName(), KeyboardA.type); //聯想 鍵盤
    let KeyboardB = new Keyboard('戴爾');
    console.log(KeyboardB.getName(), KeyboardB.type); //戴爾 鍵盤

我以爲這個抽象工廠的話 相對前兩種而言 組合比較靈活

抽象工廠不直接建立實例，我的認爲在大型項目的話應該蠻實用的。

以上是我的的看法，接觸很少，有說的不對或不足之處，請批評指正。