1.描述

提供一個一系列或相互依賴對象的接口，而無需指定他們具體的類。

2.模式的使用

·抽象產品(Product)：一個抽象類或接口，負責定義具體產品必須實現的方法。

·具體產品(ConcreteProduct)：具體產品是一個類，實現或繼承抽象產品。

·抽象工廠(AbstractFactory)：一個抽象類或接口，定義若幹抽象方法。

·具體工廠(ConcreteFactory)：實現或繼承抽象工廠，返回具體產品的實例。

3.使用情景

·系統需要為用戶提供多個對象，但不希望用戶直接使用new運算符實例化對象，即希望用戶和創建對象的類脫藕。

·系統需要為用戶提供多個對象，以便用戶聯合使用他們，但又不希望用戶決定如何關聯他們。

·系統需要為用戶提供一系列對象，但只需要用戶知道這些對象有哪些方法可用，不需要用戶知道這些對象的創建過程。

4.優點

·使用戶和創建對象的類脫藕。

·可以方便的為用戶提供一些列對象。用戶使用不同的具體工廠就可以得到一組相關的對象，同時也避免用戶混淆不同系列的對象。

·可以隨時增加“具體工廠”為用戶提供一組相關的對象。

5.UML圖

6.案例

在前面的中介者模式的案例，將買方和賣方用工廠模式生產出來。

  1 package 工廠模式;
  2 
  3 import java.util.ArrayList;
  4 import java.util.HashMap;
  5 import
 
 java.util.Iterator;
  6 import java.util.Set;
  7 
  8 public class test1 {
  9 
 10     public static void main(String[] args) {
 11         ConcreteMediator mediator  = new ConcreteMediator();
 12         Factory f = new Factory(mediator);
 13         ArrayList<Colleague> l1 = f.createBuyers(2);
 
 14         for(int i = 0; i <= 1; i++)
 15             ((Buyer1)l1.get(i)).setName("買家" + i);
 16         ArrayList<Colleague> l2 = f.createSellers(2);
 17         for(int i = 0; i <= 1; i++)
 18             ((Seller1)l2.get(i)).setName("賣家" + i);
 19         l1.get(0).sendMess("我要買汽車");
 20         System.out.println(l1.get(0).getName());
 21     }
 22 
 23 }
 24 
 25 /*
 26  * 同事
 27  */
 28 interface Colleague{
 29     public void sendMess(String mess); //發布信息
 30     public void receiveMess(Colleague colleague, String mess);  //接受信息
 31     public void setName(String mess);
 32     public String getName();
 33 }
 34 
 35 /*
 36  * 買家抽象類
 37  */
 38 abstract class Buyer implements Colleague{
 39     private final static String IDENTITY= "我是買家";
 40     public String getIdentity(){
 41         return IDENTITY;
 42     }
 43 }
 44 
 45 /*
 46  * 賣家抽象類
 47  */
 48 abstract class Seller implements Colleague{
 49     private final static String IDENTITY= "我是賣家";
 50     public String getIdentity(){
 51         return IDENTITY;
 52     }
 53 }
 54 /*
 55  * 中介者
 56  */
 57 interface Mediator{
 58     public void registColleague(Colleague colleague);
 59     public void deliverMess(Colleague colleague, String mess);
 60 }
 61 
 62 /*
 63  * 具體中介者
 64  */
 65 class ConcreteMediator implements Mediator{
 66     /*
 67      * 在這裏采用HashMap容器。因為買賣雙方需要進行一對一的信息交互才能達成一致，肯定要對數
 68      * 據進行查詢，這種結構查詢很快。但在本案例中，只實現了一對多的廣播信息功能，實
 69      * 際上沒用到HashMap的查詢優勢。如果只進行遍歷，可以換成List結構。
 70      */
 71     private HashMap<Integer, Buyer> buyerMap; //儲存買家對象
 72     private HashMap<Integer, Seller> sellerMap;  //儲存賣家對象
 73     ConcreteMediator(){
 74         this.buyerMap = new HashMap<Integer, Buyer>();
 75         this.sellerMap = new HashMap<Integer, Seller>();
 76     }
 77     public void registColleague(Colleague colleague) {
 78         //先判斷是哪一類，再儲存買家、賣家的引用
 79         if(colleague.getClass().getGenericSuperclass().toString().equals("class 工廠模式.Buyer"))
 80             this.buyerMap.put(colleague.hashCode(), (Buyer) colleague);
 81         if(colleague.getClass().getGenericSuperclass().toString().equals("class 工廠模式.Seller"))
 82             this.sellerMap.put(colleague.hashCode(), (Seller) colleague);
 83     }
 84 
 85     public void deliverMess(Colleague colleague, String mess) {
 86         //買家將消息發送給所有賣家
 87         if(colleague.getClass().getGenericSuperclass().toString().equals("class 工廠模式.Buyer")){
 88             //遍歷HashMap的方法
 89             Set<Integer> set = this.sellerMap.keySet();
 90             Iterator<Integer> iterator = set.iterator();
 91             Integer i;
 92             while(iterator.hasNext()){
 93                 i = iterator.next();
 94                 this.sellerMap.get(i).receiveMess(this.sellerMap.get(i),mess);
 95             }
 96         }
 97         //賣家將所有消息發送給買家
 98         if(colleague.getClass().getGenericSuperclass().toString().equals("class 工廠模式.Seller")){
 99             //遍歷HashMap的方法
100             Set<Integer> set = this.buyerMap.keySet();
101             Iterator<Integer> iterator = set.iterator();
102             Integer i;
103             while(iterator.hasNext()){
104                 i = iterator.next();
105                 this.buyerMap.get(i).receiveMess(this.buyerMap.get(i), mess);
106             }
107         }
108     }
109     
110 } 
111 
112 /*
113  * 具體同事
114  */
115 class Buyer1 extends Buyer{
116     private String name;
117     Mediator mediator; //存儲中介者的引用，也許還有其他中介者用來實現其他的信息交互。
118     Buyer1(Mediator mediator){
119         this.mediator  = mediator;
120         mediator.registColleague(this);
121     }
122     public void sendMess(String mess) {
123         mediator.deliverMess(this, mess);
124     }
125 
126     public void receiveMess(Colleague colleague, String mess) {
127         System.out.println("賣家發出消息   " + colleague.getName() + "接受信息:" + mess);
128     }
129 
130     public void setName(String name) {
131         this.name  = name;
132     }
133 
134     public String getName() {
135         return name;
136     }
137 }
138 
139 /*
140  * 具體同事
141  */
142 class Seller1 extends Seller{
143     private String name;
144     Mediator mediator;
145     Seller1(Mediator mediator){
146         this.mediator  = mediator;
147         mediator.registColleague(this);
148     }
149     public void sendMess(String mess) {
150         mediator.deliverMess(this, mess);
151     }
152 
153     public void receiveMess(Colleague colleague, String mess) {
154         System.out.println("買家發出消息   " + colleague.getName() + "接受信息:" + mess);
155     }
156 
157     public void setName(String name) {
158         this.name  = name;
159     }
160 
161     public String getName() {
162         return name;
163     }
164 }
165 
166 /*
167  * 工廠接口
168  */
169 interface abstractFactory{
170     public Colleague createBuyer();
171     public Colleague createSeller();
172     public ArrayList<Colleague> createBuyers(int n);
173     public ArrayList<Colleague> createSellers(int n);
174 }
175 
176 /*
177  * 具體工廠
178  */
179 class Factory implements abstractFactory{
180     private Mediator mediator;
181     public Factory(Mediator mediator){
182         this.mediator = mediator;
183     }
184     public Colleague createBuyer() {
185         return new Buyer1(mediator);
186     }
187 
188     public Colleague createSeller() {
189         return new Seller1(mediator);
190     }
191 
192     public ArrayList<Colleague> createBuyers(int n) {
193         ArrayList<Colleague> list = new ArrayList<Colleague>();
194         for(int i = 0; i < n; i++)
195             list.add(new Buyer1(mediator));
196         return list;
197     }
198 
199     public ArrayList<Colleague> createSellers(int n) {
200         ArrayList<Colleague> list = new ArrayList<Colleague>();
201         for(int i = 0; i < n; i++)
202             list.add(new Seller1(mediator));
203         return list;
204     }
205     
206 }

設計模式（十）——抽象工廠模式