对象创建型之AbstractFactory（抽象工厂模式）

额外说下，工厂模式和策略模式的区别

可能有些小伙伴也疑惑， 工厂模式使用的场景之一有：当系统的配置由多个产品中的一个来配置的时候，可以适用工厂模式。 而策略模式 的使用场景一般事，先定义一个算法族，当程序使用的时候掉用掉用其中的算法或者业务方法。

区别有以下

1、工厂模式是创建型模式，策略模式是行为型模式。
2、工厂模式是适应对象的变化，而策略是适应行为的变化。
3、工厂模式是具体化对象后，掉用其公开的具体方法。而策略模式是先指定一个具体的类，然后掉用一个抽象方法。
4、工厂模式是重写父类，而策略模式是掉用不同类的方法。

工厂设计模式

意图

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

别名

Kit

动机

假如有这么一个场景，一个汽车公司能造  a、b、c三种类型的车，他们既有相同的部分，比如 发动机相同，也有不同的地方，比如外观、空间大小等。那么对于这问题，让我们设置工序，该怎么办？ 为了保证风格标准的可移植性，你不应该为一个特定的视感外观都设置一道工序。
对此，我们可以抽出一个基础类，将相同工序的地方全部打包在基类完成，特定的的构造部分在子类完成。

适用性

－ 一个系统要独立于它的产品的创建、组合和表示
－ 一个系统要由多个产品中的一个来配置
－ 一个产品类库，你只想显示他的接口二部显示它的实现。

例子：

通过抽象工场模式，生产三种类型的车。

CarType:车子的类型

package com.create.factory;
public enum CarType {
    //奥迪，宝马，奔驰
    AODI, BAOMA, BENCI
}

Car

package com.create.factory;

public abstract class Car {
    public Car(CarType model) {
        this.model = model;
        arrangeParts();
    }

    private void arrangeParts() {

    }

    protected abstract void construct();

    private CarType model = null;

    public CarType getModel() {
        return model;
    }

    public void setModel(CarType model) {
        this.model = model;
    }

}

三种车的具体实现

package com.create.factory;

public class BENCICar extends Car{

    public BENCICar() {
        super(CarType.BENCI);
        construct();
    }

    @Override
    protected void construct() {
        System.out.println("一辆   奔驰   建造完成。");
    }

}

package com.create.factory;

public class BAOMACar extends Car{

    public BAOMACar() {
        super(CarType.BAOMA);
        construct();
    }

    @Override
    protected void construct() {
        System.out.println("一辆   宝马   构造完成。");
    }

}

package com.create.factory;

public class AODICar extends Car {

    public AODICar() {
        super(CarType.AODI);
        construct();
    }

    @Override
    protected void construct() {
        System.out.println("一辆   奥迪   构造完成。");
    }

}

工厂

package com.create.factory;

public class CarFactory {
    public static Car buildFactory(CarType model) {
        Car car = null;
        switch (model) {
        case AODI:
            car=new AODICar();
            break;
        case BENCI:
            car=new BENCICar();
            break;
        case BAOMA:
            car=new BAOMACar();
            break;
        default:
            break;
        }
        return car;
    }
}

测试

package com.create.factory;

public class AbstractFactoryTest {
    public static void main(String[] args) {
        System.out.println(CarFactory.buildFactory(CarType.AODI));
        System.out.println(CarFactory.buildFactory(CarType.BENCI));
        System.out.println(CarFactory.buildFactory(CarType.BAOMA));
    }
}

结果：

一辆 奥迪 构造完成。
com.create.factory.AODICar@7f23663b
一辆 奔驰 建造完成。
com.create.factory.BENCICar@6d0cecb2
一辆 宝马 构造完成。
com.create.factory.BAOMACar@6b87d20c

---

thx,欢迎讨论。