设计模式（十）——抽象工厂模式

1.描述

提供一个一系列或相互依赖对象的接口，而无需指定他们具体的类。

2.模式的使用

·抽象产品(Product)：一个抽象类或接口，负责定义具体产品必须实现的方法。

·具体产品(ConcreteProduct)：具体产品是一个类，实现或继承抽象产品。

·抽象工厂(AbstractFactory)：一个抽象类或接口，定义若干抽象方法。

·具体工厂(ConcreteFactory)：实现或继承抽象工厂，返回具体产品的实例。

3.使用情景

·系统需要为用户提供多个对象，但不希望用户直接使用new运算符实例化对象，即希望用户和创建对象的类脱藕。

·系统需要为用户提供多个对象，以便用户联合使用他们，但又不希望用户决定如何关联他们。

·系统需要为用户提供一系列对象，但只需要用户知道这些对象有哪些方法可用，不需要用户知道这些对象的创建过程。

4.优点

·使用户和创建对象的类脱藕。

·可以方便的为用户提供一些列对象。用户使用不同的具体工厂就可以得到一组相关的对象，同时也避免用户混淆不同系列的对象。

·可以随时增加“具体工厂”为用户提供一组相关的对象。

5.UML图

6.案例

在前面的中介者模式的案例，将买方和卖方用工厂模式生产出来。

package 工厂模式;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class test1 {

    public static void main(String[] args) {
        ConcreteMediator mediator  = new ConcreteMediator();
        Factory f = new Factory(mediator);
        ArrayList<Colleague> l1 = f.createBuyers(2);
        for(int i = 0; i <= 1; i++)
            ((Buyer1)l1.get(i)).setName("买家" + i);
        ArrayList<Colleague> l2 = f.createSellers(2);
        for(int i = 0; i <= 1; i++)
            ((Seller1)l2.get(i)).setName("卖家" + i);
        l1.get(0).sendMess("我要买汽车");
        System.out.println(l1.get(0).getName());
    }

}

/*
 * 同事
 */
interface Colleague{
    public void sendMess(String mess); //发布信息
    public void receiveMess(Colleague colleague, String mess);  //接受信息
    public void setName(String mess);
    public String getName();
}

/*
 * 买家抽象类
 */
abstract class Buyer implements Colleague{
    private final static String IDENTITY= "我是买家";
    public String getIdentity(){
        return IDENTITY;
    }
}

/*
 * 卖家抽象类
 */
abstract class Seller implements Colleague{
    private final static String IDENTITY= "我是卖家";
    public String getIdentity(){
        return IDENTITY;
    }
}
/*
 * 中介者
 */
interface Mediator{
    public void registColleague(Colleague colleague);
    public void deliverMess(Colleague colleague, String mess);
}

/*
 * 具体中介者
 */
class ConcreteMediator implements Mediator{
    /*
     * 在这里采用HashMap容器。因为买卖双方需要进行一对一的信息交互才能达成一致，肯定要对数
     * 据进行查询，这种结构查询很快。但在本案例中，只实现了一对多的广播信息功能，实
     * 际上没用到HashMap的查询优势。如果只进行遍历，可以换成List结构。
     */
    private HashMap<Integer, Buyer> buyerMap; //储存买家对象
    private HashMap<Integer, Seller> sellerMap;  //储存卖家对象
    ConcreteMediator(){
        this.buyerMap = new HashMap<Integer, Buyer>();
        this.sellerMap = new HashMap<Integer, Seller>();
    }
    public void registColleague(Colleague colleague) {
        //先判断是哪一类，再储存买家、卖家的引用
        if(colleague.getClass().getGenericSuperclass().toString().equals("class 工厂模式.Buyer"))
            this.buyerMap.put(colleague.hashCode(), (Buyer) colleague);
        if(colleague.getClass().getGenericSuperclass().toString().equals("class 工厂模式.Seller"))
            this.sellerMap.put(colleague.hashCode(), (Seller) colleague);
    }

    public void deliverMess(Colleague colleague, String mess) {
        //买家将消息发送给所有卖家
        if(colleague.getClass().getGenericSuperclass().toString().equals("class 工厂模式.Buyer")){
            //遍历HashMap的方法
            Set<Integer> set = this.sellerMap.keySet();
            Iterator<Integer> iterator = set.iterator();
            Integer i;
            while(iterator.hasNext()){
                i = iterator.next();
                this.sellerMap.get(i).receiveMess(this.sellerMap.get(i),mess);
            }
        }
        //卖家将所有消息发送给买家
        if(colleague.getClass().getGenericSuperclass().toString().equals("class 工厂模式.Seller")){
            //遍历HashMap的方法
            Set<Integer> set = this.buyerMap.keySet();
            Iterator<Integer> iterator = set.iterator();
            Integer i;
            while(iterator.hasNext()){
                i = iterator.next();
                this.buyerMap.get(i).receiveMess(this.buyerMap.get(i), mess);
            }
        }
    }
    
} 

/*
 * 具体同事
 */
class Buyer1 extends Buyer{
    private String name;
    Mediator mediator; //存储中介者的引用，也许还有其他中介者用来实现其他的信息交互。
    Buyer1(Mediator mediator){
        this.mediator  = mediator;
        mediator.registColleague(this);
    }
    public void sendMess(String mess) {
        mediator.deliverMess(this, mess);
    }

    public void receiveMess(Colleague colleague, String mess) {
        System.out.println("卖家发出消息   " + colleague.getName() + "接受信息:" + mess);
    }

    public void setName(String name) {
        this.name  = name;
    }

    public String getName() {
        return name;
    }
}

/*
 * 具体同事
 */
class Seller1 extends Seller{
    private String name;
    Mediator mediator;
    Seller1(Mediator mediator){
        this.mediator  = mediator;
        mediator.registColleague(this);
    }
    public void sendMess(String mess) {
        mediator.deliverMess(this, mess);
    }

    public void receiveMess(Colleague colleague, String mess) {
        System.out.println("买家发出消息   " + colleague.getName() + "接受信息:" + mess);
    }

    public void setName(String name) {
        this.name  = name;
    }

    public String getName() {
        return name;
    }
}

/*
 * 工厂接口
 */
interface abstractFactory{
    public Colleague createBuyer();
    public Colleague createSeller();
    public ArrayList<Colleague> createBuyers(int n);
    public ArrayList<Colleague> createSellers(int n);
}

/*
 * 具体工厂
 */
class Factory implements abstractFactory{
    private Mediator mediator;
    public Factory(Mediator mediator){
        this.mediator = mediator;
    }
    public Colleague createBuyer() {
        return new Buyer1(mediator);
    }

    public Colleague createSeller() {
        return new Seller1(mediator);
    }

    public ArrayList<Colleague> createBuyers(int n) {
        ArrayList<Colleague> list = new ArrayList<Colleague>();
        for(int i = 0; i < n; i++)
            list.add(new Buyer1(mediator));
        return list;
    }

    public ArrayList<Colleague> createSellers(int n) {
        ArrayList<Colleague> list = new ArrayList<Colleague>();
        for(int i = 0; i < n; i++)
            list.add(new Seller1(mediator));
        return list;
    }
    
}