Abstract Factory 模式读书笔记与举例

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生产商的衬衫

转载于:https://blog.51cto.com/77857/148116