大话设计模式二：抽象工厂模式

一.模式定义

抽象工厂模式属于对象创建型模式。
Abstract Factory Pattern: Provide an interface for creating families of related or dependent objects without specifying their concrete classes. 

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。
与简单工厂模式相比，抽象工厂可以创建多个不同种类-（产品族）的产品，这是简单工厂模式所不具备的。

 

二.模式要素

1.抽象工厂：声明生成众多不同种类抽象产品的方法

2.具体工厂：执行生成一系列抽象产品的方法，生成一系列具体的产品

3.抽象产品：为这一系列的某一种产品声明接口

4.具体产品：定义具体工厂生成的具体产品的对象，实现产品接口

5.使用者

 

三.举例说明

我们来举一个武器工厂的例子。现在有武器工厂A和武器工厂B。

其中两个工厂都是既生产枪支也生产子弹（不同类型的产品，或者说不同产品族的产品）。

A工厂生产A型号枪支与A型号子弹，B工厂生产B型号枪支与B型号子弹（两工厂生产的产品种类一样）。

那么关系图如下所示。

 

四.模式实例

工程结构如下：

1.抽象武器工厂：IWeaponFactory.java

package abstractFactory;

/**
 * @program: DesignModes
 * @description: 抽象武器工厂
 * @author: Lei Dong
 * @create: 2018-09-02 11:26
 **/
public interface IWeaponFactory {
    /**
     * 生产枪支
     *
     * @return
     */
    public IGun produceGun();

    /**
     * 生产子弹
     *
     * @return
     */
    public IBullet produceBullet();
}

2.武器工厂A：WeaponFactoryA.java

package abstractFactory;

/**
 * @program: DesignModes
 * @description: 具体武器工厂A
 * @author: Lei Dong
 * @create: 2018-09-02 11:26
 **/
public class WeaponFactoryA implements IWeaponFactory {
    /**
     * 生产枪支A
     *
     * @return
     */
    @Override
    public IGun produceGun() {
        return new GunA();
    }

    /**
     * 生产子弹A
     *
     * @return
     */
    @Override
    public IBullet produceBullet() {
        return new BulletA();
    }
}

3.武器工厂B：WeaponFactoryB.java

package abstractFactory;

/**
 * @program: DesignModes
 * @description: 武器工厂B
 * @author: Lei Dong
 * @create: 2018-09-02 11:27
 **/
public class WeaponFactoryB implements IWeaponFactory {
    /**
     * 生产枪支B
     *
     * @return
     */
    @Override
    public IGun produceGun() {
        return new GunB();
    }

    /**
     * 生产子弹B
     *
     * @return
     */
    @Override
    public IBullet produceBullet() {
        return new BulletB();
    }
}

4.抽象枪支：IGun.java

package abstractFactory;

/**
 * @program: DesignModes
 * @description: 枪支抽象类
 * @author: Lei Dong
 * @create: 2018-09-02 11:28
 **/
public interface IGun {
    /**
     * 展示枪支的信息
     */
    public void showGunInfo();
}

5.枪支A：GunA.java

package abstractFactory;

/**
 * @program: DesignModes
 * @description: 枪支A
 * @author: Lei Dong
 * @create: 2018-09-02 11:28
 **/
public class GunA implements IGun {
    /**
     * 展示枪支A的信息
     */
    @Override
    public void showGunInfo() {
        System.out.println("我是枪支A");
    }
}

6.枪支B：GunB.java

package abstractFactory;

/**
 * @program: DesignModes
 * @description: 枪支B
 * @author: Lei Dong
 * @create: 2018-09-02 11:29
 **/
public class GunB implements IGun {
    /**
     * 展示枪支B的信息
     */
    @Override
    public void showGunInfo() {
        System.out.println("我是枪支B");
    }
}

7.抽象子弹：IBullet.java

package abstractFactory;

/**
 * @program: DesignModes
 * @description: 子弹抽象类
 * @author: Lei Dong
 * @create: 2018-09-02 11:28
 **/
public interface IBullet {
    /**
     * 展示子弹的信息
     */
    public void showBulletInfo();
}

8.子弹A：BulletA.java

package abstractFactory;

/**
 * @program: DesignModes
 * @description: 子弹A
 * @author: Lei Dong
 * @create: 2018-09-02 11:29
 **/
public class BulletA implements IBullet {
    /**
     * 展示子弹A的信息
     */
    @Override
    public void showBulletInfo() {
        System.out.println("我是子弹A");
    }
}

9.子弹B：BulletB.java

package abstractFactory;

/**
 * @program: DesignModes
 * @description: 子弹B
 * @author: Lei Dong
 * @create: 2018-09-02 11:29
 **/
public class BulletB implements IBullet {
    /**
     * 展示子弹B的信息
     */
    @Override
    public void showBulletInfo() {
        System.out.println("我是子弹B");
    }
}

10.使用者：Main.java

package abstractFactory;

/**
 * @program: DesignModes
 * @description: 使用者
 * @author: Lei Dong
 * @create: 2018-09-02 11:25
 **/
public class Main {
    public static void main(String[] args) {
        IWeaponFactory weaponFactory = new WeaponFactoryA();
        IGun gun = weaponFactory.produceGun();
        IBullet bullet = weaponFactory.produceBullet();
        gun.showGunInfo();
        bullet.showBulletInfo();

        System.out.println("======================");

        IWeaponFactory weaponFactory1 = new WeaponFactoryB();
        IGun gun1 = weaponFactory1.produceGun();
        IBullet bullet1 = weaponFactory1.produceBullet();
        gun1.showGunInfo();
        bullet1.showBulletInfo();
    }
}

运行结果：

 

五.总结

1.抽象工厂模式的优点
（1）隔离了具体类的生成，使用者并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。

（2）所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。

（3）应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用。

2.抽象工厂模式的缺点
（1）在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品。在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对接口进行扩展，这将涉及到对抽象工厂角色及其所有子类的修改。
（2）增加新的工厂和产品族容易，增加新的产品等级结构麻烦。

3.抽象工厂模式的适用环境
（1）一个系统不依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是重要的。 
（2）系统中有多于一个的产品族，而每次只使用其中某一产品族。
（3）属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。
（4）系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。