javascript抽象工廠模式

 

一。簡單工廠

定義：簡單工廠模式中，可以根據參數的不同返回不同類的實例。簡單工廠模式專門定義一個類來負責創建其他類的實例，被創建的實例通常都具有共同的父類。   

比如你去專門賣鼠標的地方你可以買各種各樣的鼠標

 

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

上邊那個new之前也看了很多例子有的有 有的沒有  后來發現因為mouse、keyboard、headset等構造函數保存到了shop.prototype中，也就意味着我們必須實例化shop函數才能夠進行以上對象的實例化

 

 

三。抽象工廠模式

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

前邊的兩個都是直接生產實例的，開始以為抽象工廠也是但是后來發現抽象工廠更像是生產工廠，其實抽象工廠其實是實現子類繼承父類的方法。

 

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

比如說上邊他們有了個電腦店的門店  現在電腦店火了 又開了一個電腦店  然后這兩個電腦店一個是聯想的  一個是戴爾的   

 

核心代碼
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); //戴爾 鍵盤

 我覺得這個抽象工廠的話    相對前兩種而言   如果抽象函數比較全的話  可能少了很多的new吧    組合比較靈活

抽象工廠不直接創建實例，個人認為在大型項目的話應該蠻實用的。

以上是個人的見解，接觸不多，有說的不對或不足之處，請批評指正。