準備找工作那會看到了一本神書，《Head First 設計模式》,從此對設計模式有了很深的親睞，但是因為自己的專案經驗少的可憐，所以也基本沒有用過這些神一樣的方法，時間一長也就都忘乾淨了。現在工作了，師兄給了一個500M的程式碼，讓我吃透它。這期間真的有很多問題，很迷惑。忽然想起了我之前看的書，於是重新拿出來溫習。

如果說設計模式是聖經，那麼這本書就是小人漫畫版的啟蒙聖經。入門看真的很好，但因為工作需要沒有這麼多時間，快餐式的是最合適的。於是在網上看到了一個網址，介紹23種設計模式很是靠譜。http://zz563143188.iteye.com/blog/1847029 這是這位大牛的網址。

以前看書的時候，感覺工廠模式種類繁多，根本就分不清楚，但是看了他的部落格之後，有種撥雲見月的感覺。於是乎就自己寫下了這幾個工廠模式的例子來練習，實現例項沒有自己設計是參照網上的。

寫完之後就感覺自己分清並掌握了這幾個模式，下面就總結一下。

工廠模式是三類設計模式中的建立式模式，工廠模式分為三種，簡單工廠方法，複雜工廠，還有抽象工廠

下面先看一下他們的實現

一，簡單工廠模式

首先定義一個Isend介面

public interface Isend {
	public void sendMessage();
}

然後new幾個sender，實現Isend介面

public class MailSender implements Isend {

	public void sendMessage() {
		// TODO Auto-generated method stub
		System.out.println("Use MailSender send the message!");
	}

}
 

public class PhoneSender implements Isend{

	public void sendMessage() {
		// TODO Auto-generated method stub
		System.out.println("Use PhoneSender send the message!");
	}

}

然後就是做一個工廠，讓工廠來生產這幾個sender

public class SenderFactory {
	public Isend productSender(String type) {
		if("Mail".equals(type)) {
			return new MailSender();
		}else if("Phone".equals(type)) {
			return new PhoneSender();
		}else 
			<span style="color:#ff0000;">return new NullSender();</span>
	}
}
 

其中紅色部分，就是暴露出了簡單工廠的缺點，就是當type的型別和系統定義的步一樣時，有可能是輸入錯誤等，返回的就是一個空型別了，這是簡單工廠的天生缺點

看一下測試

public class Test {
	public static void main(String[] args) {
		SenderFactory factory = new SenderFactory();
		Isend mailSender = factory.productSender("Mail");
		mailSender.sendMessage();
		
		Isend phoneSender = factory.productSender("Phone");
		phoneSender.sendMessage();
		
		Isend errorySender = factory.productSender("123");
		errorySender.sendMessage();
		
	}
}

測試結果：

Use MailSender send the message!
Use PhoneSender send the message!
No SenderFactory product sender!

因為這個工廠相當於單個生產線，所以每種產品都會從這條生產線中產出，所以如果輸入是本來生產線中沒有的，那麼就只能報錯了。根據這種情況，於是就想可以再多出幾條生產線啊。就是下面的複雜工廠該出場了。

二、複雜工廠：

其他的都一樣，就是在工廠中多加幾條生產線，所以直接看SenderFactory類就可以了

package com.designpattern.complexfactory.factory;

import com.designpattern.complexfactory.isend.Isend;
import com.designpattern.complexfactory.sender.MailSender;
import com.designpattern.complexfactory.sender.PhoneSender;

public class SenderFactory {
	public Isend productMailSender() {
		return new MailSender();
	} 
	
	public Isend productPhoneSender() {
		return new PhoneSender();
	}
}

在這裡，我做了兩條生產線，每條生產線只負責生產一種產品，所以，這樣就沒有輸入錯誤的情況了，看看測試

public class Test {
	public static void main(String[] args) {
		SenderFactory factory = new SenderFactory();
		Isend mailSender = factory.productMailSender();
		mailSender.sendMessage();
		
		Isend phoneSender = factory.productPhoneSender();
		phoneSender.sendMessage();
		
	}
}

解決了？好像發現了兩個問題。

1，工廠方法裡不需要建立例項，直接呼叫就行，那好辦就把它設定為靜態工廠，就實現了不需要例項化，直接建立。

public class SenderFactory {
	public <span style="color:#ff0000;">static</span> Isend productMailSender() {
		return new MailSender();
	} 
	
	public <span style="color:#ff0000;">static</span> Isend productPhoneSender() {
		return new PhoneSender();
	}
}

下面看一下測試

public static void main(String[] args) {
		Isend mailSender = SenderFactory.productMailSender();
		mailSender.sendMessage();
		
		Isend phoneSender = SenderFactory.productPhoneSender();
		phoneSender.sendMessage();
		
	}

2，設計模式崇尚的是對擴充套件開放，對修改關閉。當有新的需求有新的產品設計出來需要生產的時候，那麼就只能更改SenderFactory這個類了，那麼不就是違背這個設計原則了嗎。可以設想，把工廠也做成多個，當有新的產品時，就建一座工廠，這樣原來的工廠就不需要更改了，就實現了工廠之間的鬆耦合。

於是抽象工廠就這麼產生了

抽象工廠：

抽象工廠就是把處理工廠的方法和處理生產線的方法一樣

首先看一下IFactory介面

public interface IFactory {
	public Isend productSender();
}

所有的工廠都實現此介面，也就意味著所有的工廠都可以生產產品，看一下這幾個工廠

public class MailSender implements Isend{

	public void SendMessage() {
		// TODO Auto-generated method stub
		System.out.println("Use MailSender send the message!");
	}

}

public class PhoneSender implements Isend {

	public void SendMessage() {
		// TODO Auto-generated method stub
		System.out.println("Use PhoneSender send the message!");
	}

}

這裡我又新建了一個qq工廠，來發送qq訊息

public class QQSender implements Isend {

	public void SendMessage() {
		// TODO Auto-generated method stub
		System.out.println("User QQSender send the message!");
	}

}

工廠看完了，看一下訊息傳送器

public class MailSender implements Isend{

	public void SendMessage() {
		// TODO Auto-generated method stub
		System.out.println("Use MailSender send the message!");
	}

}

public class PhoneSender implements Isend {

	public void SendMessage() {
		// TODO Auto-generated method stub
		System.out.println("Use PhoneSender send the message!");
	}

}

public class QQSender implements Isend {

	public void SendMessage() {
		// TODO Auto-generated method stub
		System.out.println("User QQSender send the message!");
	}

}

每一種傳送器都是由不同的工廠生產出來的，當然也可以一個工廠生產多種產品，你可以試著改一下，當練手。

下面看一下測試

public class Test {
	public static void main(String[] args) {
		IFactory mailFactory = new MailSenderFactory();
		Isend mailSend = mailFactory.productSender();
		mailSend.SendMessage();
		
		IFactory phoneFactory = new PhoneSenderFactory();
		Isend phoneSend = phoneFactory.productSender();
		phoneSend.SendMessage();
		
		IFactory qqFactory = new QQSenderFactory();
		Isend qqSend = qqFactory.productSender();
		qqSend.SendMessage();
	}
}

在這個例子中，新加的qq傳送器是由qq工廠new出來的，不影響Mail 和 Phone工廠，實現了對擴充套件開放，對修改關閉的原則。

至此工廠模式就算是總結完了，還留了一個小題，就是在抽象工廠中，讓一個工廠生產多個產品。

這裡有一個坑，也同時給我自己挖了一個，下面晒一下我的答案：

首先我新建了一個WeiSender，想讓QQSenderFactory也同時能生產WeiSender

public class WeiSender implements Isend {

	public void SendMessage() {
		// TODO Auto-generated method stub
		System.out.println("Use WeiSender send the message!");
	}

}

把QQSenderFactory類做了一下調整

public class QQSenderFactory implements IFactory{

	public Isend productSender() {
		// TODO Auto-generated method stub
		return new QQSender();
	}
	
	<span style="color:#ff0000;">public Isend productWeiSender() {
		return new WeiSender();
	}</span>

}

其中紅色部分是我加的方法

於是在測試的時候，我就想直接用

IFactory qqFactory = new QQSenderFactory();

生產出來的qqFactory來執行productWeiSender()方法，但是發現是錯誤的，這裡就是個坑，回頭看qqFactory是怎麼來的，是由IFactory來的，那麼就只能執行IFactory介面中帶有的方法啦。

所以如果還想執行其他的方法，那就得：

<span style="color:#ff0000;">QQSenderFactory qqf = new QQSenderFactory();</span>
		Isend qqs = qqf.productWeiSender();
		qqs.SendMessage();

使用這種方法來new一個qqFactory就可以執行QQSenderFactory中的所喲方法了。

看一下測試

Use MailSender send the message!
Use PhoneSender send the message!
User QQSender send the message!
Use WeiSender send the message!

建造者模式

看完了工廠模式，是不是覺得意猶未盡，還差點啥？

對了，工廠模式建立的是單個類的模式，工廠可是可以根據訂貨單來大批量生產的。

於是建造者模式就誕生了。

下面看一下他的程式碼，相信一看程式碼就很明確了

public interface ISend {
	public void Send() ;
}

public class MailSender implements ISend {

	public void Send() {
		// TODO Auto-generated method stub
		System.out.println("Use MailSender send the message!");
	}

}

public interface IFactory {
	
	public List<ISend> productSender(int count) ;
}

public class MailSenderFactory implements IFactory {

	private List<ISend> list ; 
	
	public MailSenderFactory() {
		list = new ArrayList();
	}
	
	public List<ISend> productSender(int count) {
		for(int i = 0; i < count; i++) {
			list.add(new MailSender());
		}
		return list;
	}
	
	
}

public class Test {
	public static void main(String[] args) {
		MailSenderFactory mailFactory = new MailSenderFactory();
		List list = mailFactory.productSender(3);
		for(int i = 0; i < list.size(); i++) {
			ISend sender = (ISend) list.get(i);
			sender.Send();
		}
	}
}

不用多說了吧，我想應該一看就能明白

建造者模式是可以創造出很多複雜的東西，所以以後在用的時候可以考慮清楚，那種模式更適合