JAVA设计模式【创建型模式】之【ABSTRACT FACTOR

其他对象创建型模式：

• Prototype （原型模式）
• FactoryMethod（工厂方法）
• Builder（建造者模式）
• Singleton（单例模式）

1. 意图

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

2. 适用性

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

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

3. 参与者

• Abstract Factory ——声明一个创建抽象产品对象的操作接口。
• ConcreteFactory ——实现创建具体产品对象的操作。
• AbstractProduct ——为一类产品对象声明一个接口。
• ConcreteProduct ——定义一个将被相应的具体工厂创建的产品对象。
• Client ——仅适用有AbstractFactory和AbstractProduct类声明的接口。

4.效果

优点：
1). 分离了具体的类
2). 易于交换产品系列
3). 有利于产品的一致性

缺点：
4). 难以支持新种类的产品

5.实例

我这里用宝马、奔驰、奥迪汽车的例子来进行实践此模式。大家都知道汽车都分国产和进口之分，所以这里我们的产品就是国产车和进口车，那生产汽车的就会有生产国产车的汽车厂和生产进口车的汽车厂。

AbstractProduct对应的就是汽车这一类产品对象，产品有

奥迪 :IAudi.java

 public interface IAudi {
    void drive();
}

奔驰：IBenz.java

public interface IBenz {
    void drive();
}

宝马：IBmw.java

public interface IBmw {
    void drive();
}

那么ConcreteProduct对应的就是进口的车和国产的车，所以就有下面结构：

image.png

这里只看奔驰的的国产和进口的两种不同实现：

HomeMadeBenz.java

/**
 * Description: 北京奔驰 <br>
 * Author:Terry<br>
 * Date:2018/3/12 上午11:06
 */
public class HomeMadeBenz implements IBenz {
    @Override
    public void drive() {
        System.out.println("驾驶：北京奔驰");
    }
}

ImportedBenz.java

/**
 * Description:  <br>
 * Author:Terry<br>
 * Date:2018/3/12 上午11:06
 */
public class ImportedBenz implements IBenz {
    @Override
    public void drive() {
        System.out.println("驾驶：进口奔驰");
    }
}

定义好混合产品之后，剩下的就是 AbstractFactory 和 ConcreteFactory 了，宝马、奥迪、奔驰肯定都是汽车工厂里生产出来的，那定义统一的接口就是：

ICarFactory.java

public interface ICarFactory {
    IAudi createAudi();
    IBmw createBMW();
    IBenz createBenz();
}

这里只针对国产车和进口车来作为Factory的类型，对应代码如下：

国产车：HomeMadeCarFactory.java

/**
 * Description: 国产车Factory <br>
 * Author:Terry<br>
 * Date:2018/3/12 上午11:02
 */
public class HomeMadeCarFactory implements ICarFactory {

    @Override
    public IAudi createAudi() {
        return new HomeMadeAudi();
    }

    @Override
    public IBmw createBMW() {
        return new HomeMadeBmw();
    }

    @Override
    public IBenz createBenz() {
        return new HomeMadeBenz();
    }
}

进口车：ImportedCarFactory.java

/**
 * Description: 进口车Factory <br>
 * Author:Terry<br>
 * Date:2018/3/12 上午11:02
 */

public class ImportedCarFactory implements ICarFactory {
    @Override
    public IAudi createAudi() {
        return new ImportedAudi();
    }

    @Override
    public IBmw createBMW() {
        return new ImportedBmw();
    }

    @Override
    public IBenz createBenz() {
        return new ImportedBenz();
    }
}

最后，我们来测试一下：

/**
 * Creational:AbstractFactory
 */
public static void testAbstractFactory() {
    //生产国产车
    ICarFactory homeMadeCarFactory = new HomeMadeCarFactory();

    final IAudi homeMadeAudi = homeMadeCarFactory.createAudi();
    homeMadeAudi.drive();

    final IBmw homeMadeBmw = homeMadeCarFactory.createBMW();
    homeMadeBmw.drive();

    final IBenz homeMadeBenz = homeMadeCarFactory.createBenz();
    homeMadeBenz.drive();

    System.out.println("");

    //生产进口车
    ICarFactory importedCarFactory = new ImportedCarFactory();

    final IAudi importedAudi = importedCarFactory.createAudi();
    importedAudi.drive();

    final IBmw importedBmw = importedCarFactory.createBMW();
    importedBmw.drive();

    final IBenz importedBenz = importedCarFactory.createBenz();
    importedBenz.drive();
}

运行结果如下图：

运行结果