个人在CSDN的BLOG:http://blog.csdn.net/feb13/article/details/7833473

以下是读《设计模式——可复用面向对象软件的基础》的读书笔记。

ABSTRACT FACTORY抽象工厂

 

1、 意图

提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

2、 别名

Kit

3、 适用性

在以下情况可以使用Abstract Factory模式

  • 一个系统要独立于它的产品的创建、组合和表示时
  •  一个系统要由多个产品系列中的一个来配置时
  • 当你要强调一系列相关的产品对象的设计以便进行联合使用时
  • 当你提供一个产品类库,而只想显示她们的接口而不是实现时

4、 结构

此模式的结构图如下:

5、 参与者

AbstractFactory    声明一个创建抽象产品对象的操作接口


ConcreteFactory    实现创建具体产品对象的操作


AbstractProduct    为一类产品对象声明一个接口


ConcreteProduct    定义一个将被相应的具体工厂创建的产品对象;实现AbstractFactory接口


Client    仅使用由AbstractFactory和AbstractProduct类声明的接口



6、 协作
  •  通常在运行时刻创建一个ConcreteFactory类的实例。这一具体的工厂创建具有特定实现的产品对象。为创建不同的产品对象,客户端应使用不同的具体工厂。
  •  AbstractFactory将产品对象的创建延迟到它的ConcreteFactory子类。

7、 效果

Abstract Factory模式有下面的一些有点和缺点:

1)  它分离了具体的类        
              Abstract Factory模式帮助你控制一个应用创建的对象的类。因为一个工厂封装创建产品对象的责任和过程,它将客户与类的实现分离。客户通过它们的抽象接口操纵 实例。产品的类名也在具体工厂的实现中被分离;它们不出现在客户代码中。

2)  它使得易于交换产品系列     
             一个具体工厂类在一个应用中仅出现一次——即在它初始化的时候。这使得改变一个应用的具体工厂变得容易。它只需改变具体的工厂即可使用不同的产品配置,这是因为一个抽象工厂创建了一个完整的产品系列,所以整个产品系列会立刻改变。

3)  它有利于产品的一致性    
             当一系列中的产品对象被设计成一起工作时,一个应用一次只能使用同一个系列中的对象,这一点很重要。而AbstractFactory很容易实现这一点。

4)  难以支持新种类的产品    
            难以扩展抽象工厂以生产新种类的产品。这是因为AbstractFactory接口确定了可以被创建的产品集合。支持新种类的产品就需要扩展该工厂接口,这将涉及AbstractFactory类及其所有子类的改变。

8、 实现

下面是实现Abstract Factory模式的一些技术

1)将工厂作为单件       
             一个应用中一般每个产品系列只需一个ConcreteFactory的实例。因此工厂通常最好实现为一个singleton。

2)创建产品            
          AbstractFactory仅声明一个创建产品的接口,真正创建产品是由ConcreteProduct子类实现。最通常的一个方法是为每个产品定义 一个工厂方法(Factory Method)。一个具体的工厂将为每个产品重定义该工厂方法以指定产品。如果有多个可能的产品系列,具体工厂也可以使用Prototype模式实现。具 体工厂使用产品系列中每一个产品原型实例来初始化,且它通过复制它的原型来创建新的产品在基于原型的方法中,使得不是每个新的产品系列都需要一个新的具体 工厂类。

3)定义可扩展的工厂            
           AbstractFactory通常为每一种它可以生产的产品定义一个操作。产品的种类被编码在操作型构中。增加一种新的产品要求改变AbstractFactory的接口以及所有与它相关的类。

9、 代码示例

AbstractFactory
package com.examples.pattern.abstractFactory;

/**   
* 封装抽象工厂的接口,声明创建抽象产品对象的操作 
*/
public interface AbstractFactory {
    
    /**
     * 创建抽象产品A的对象
     * @return 抽象产品A的对象
     */
    public AbstractProductA createProductA();
    /**
     * 创建抽象产品B的对象
     * @return 抽象产品B的对象
     */
    public AbstractProductB createProductB();

}


ConcreteFactory
package com.examples.pattern.abstractFactory;

/**   
* 具体工厂的实现对象,实现创建具体的产品对象的操作   
*/
public class ConcreteFactory1 implements AbstractFactory {

    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }

}
package com.examples.pattern.abstractFactory;

/**
 * 具体工厂的实现对象,实现创建具体的产品对象的操作
 */
public class ConcreteFactory2 implements AbstractFactory {

    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }

}



AbstractProduct
package com.examples.pattern.abstractFactory;

/**
 * 抽象产品A的接口
 */
public interface AbstractProductA {

    /**
     * 定义产品A的相关操作
     */
    public void operate();

}


package com.examples.pattern.abstractFactory;

/**
 * 抽象产品B的接口
 */
public interface AbstractProductB {
    
    /**
     * 定义产品A的相关操作
     */
    public void operate();

}



ConcreteProduct
package com.examples.pattern.abstractFactory;

/**
 * 产品A的具体实现
 */
public class ProductA1 implements AbstractProductA {

    @Override
    public void operate() {
        System.out.println("这是产品A1的操作......");
    }

}
package com.examples.pattern.abstractFactory;

/**
 * 产品A的具体实现
 */
public class ProductA2 implements AbstractProductA {

    @Override
    public void operate() {
        System.out.println("这是产品A2的操作......");
    }

}


package com.examples.pattern.abstractFactory;

/**
 * 产品B的具体实现
 */
public class ProductB1 implements AbstractProductB {

    @Override
    public void operate() {
        System.out.println("这是产品B1的操作......");
    }

}
package com.examples.pattern.abstractFactory;

/**   
* 产品B的具体实现
*/
public class ProductB2 implements AbstractProductB {

    @Override
    public void operate() {
        System.out.println("这是产品B2的操作......");
    }

}

Client
package com.examples.pattern.abstractFactory;

public class Client {
    
    public static void main(String[] args) {
        AbstractFactory factory = null;
        AbstractProductA apa = null;
        AbstractProductB apb = null;
        
        factory = new ConcreteFactory1();
        apa = factory.createProductA();
        apb = factory.createProductB();
        apa.operate();
        apb.operate();
        
        
        factory = new ConcreteFactory2();
        apa = factory.createProductA();
        apb = factory.createProductB();
        apa.operate();
        apb.operate();
    }

}