设计模式——抽象工厂模式

Posted 2020-10-10 知止

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 }