Abstract Factory 模式的意图:
需要为特定的客户(或者对某种情况)提供对象组
Abstract Factory 模式将问题(根据职责)分解为:
1.谁在使用我们的特定对象(Client)
2.谁来决定使用哪些对象(AbstractFactory)
类图(非标准类图,为了给结合例子,稍稍修改):
代码如下:
在例子中,线索是这样的。比如你要买一件衬衫(addi的)和一条西库(nike的),牌子有nike的,还有addi的。约定对应关系如下:
AbstractFactory   ---  衣服生产商
AbstractProductB  ---  西裤
AbstractProductA  ---  衬衫
ConcreteFactory1  --    nike生产商
ConcreteFactory2  --    addi生产商
ConcreteProductA1 --    ××的衬衫
ConcreteProductB1 --    ××的裤子
(在这里ConcreteProductA1、ConcreteProductB1为ConcreteFactory1的产品)
ConcreteProductA2 --    ××的衬衫
ConcreteProductB2 --    ××的裤子
(在这里ConcreteProductA2、ConcreteProductB2为ConcreteFactory2的产品)
 
这里没有对类进行具体细化的命名,只作简单的约定,你可以根据需要修改名称。
抽象工厂:
public interface AbstractFactory {
    
/**
     *  Creates abstract product
     
*/

    AbstractProductA createProductA();

    
/**
     *  Creates abstract product
     
*/

    AbstractProductB createProductB();
}
抽象产品A:
public class AbstractProductA
{
}
抽象产品B:
public class AbstractProductB
{
}
生产1产品的工厂:
public class ConcreteFactory1 implements AbstractFactory {

private  String name;

    
public ConcreteProductA1 createProductA() {
        
return new ConcreteProductA1(name);
    }

    
    
public ConcreteProductB1 createProductB() {
        
return new ConcreteProductB1(name);
    }


    
public ConcreteFactory1(String name)
    
{
        
super();
        
this.name = name;
    }

}
生产2产品的工厂:
public class ConcreteFactory2 implements AbstractFactory
{
    
private  String name;

    
public ConcreteProductA2 createProductA()
    
{
        
return new ConcreteProductA2(name);
    }


    
public ConcreteProductB2 createProductB()
    
{
        
return new ConcreteProductB2(name);
    }


    
public ConcreteFactory2(String name)
    
{
        
super();
        
this.name = name;
    }

}
具体产品A1:
public class ConcreteProductA1 extends AbstractProductA {

    
public ConcreteProductA1(String name)
    
{
        System.out.println(name
+ "的衬衫");
    }

}
 
具体产品B1:
public class ConcreteProductB1 extends AbstractProductB
{
    
public ConcreteProductB1(String name)
    
{
        System.out.println(name
+ "的裤子");
    }

}
 
具体产品A2:
public class ConcreteProductA2 extends AbstractProductA
{
    
public ConcreteProductA2(String name)
    
{
        System.out.println(name
+ "的衬衫");
    }

}
 
具体产品B2:
public class ConcreteProductB2 extends AbstractProductB
{
    
public ConcreteProductB2(String name)
    
{
        System.out.println(name
+ "的裤子");
    }

}
 
测试Client:
public class Client
{
    
/**
     * @directed true
     
*/

    
private AbstractFactory abstractFactory;//衣服生产商
    /**
     * 
@link aggregation
     
*/

    
private AbstractProductB abstractProductB;//西裤
    /**
     * 
@link aggregation
     
*/

    
private AbstractProductA abstractProductA;//衬衫
    
    
public static void main(String[] args)
    
{
        Client client 
= new Client();
        client.buySomething();
    }

    
    
public void buySomething(){
        
//找到nike生产商
        abstractFactory  = new ConcreteFactory1("nike生产商");
        
//买一件西裤(nike)
        abstractProductB = abstractFactory.createProductB();//生产西裤
        
        
//找到addi生产商
        abstractFactory  = new ConcreteFactory2("addi生产商");//生产衬衫
        
//买一件衬衫(addi)
        abstractProductA=abstractFactory.createProductA();//生成衬衫
        
        abstractFactory 
= null;
    }

}
 
结果输出:
nike生产商的裤子
addi生产商的衬衫