思考抽象工厂模式

抽象工厂专注于产品簇的实现，主要是那些有关联关系的，如果只有一个产品的话就退化成了工厂方法模式

1.抽象工厂模式的本质

抽象工厂模式的本质:选择产品簇的实现。

产品簇（Product family）指具有相同或相似的功能结构或性能，共享主要的产品特征、组件或子结构，并通过变型配置来满足特定市场的一组产品的聚类。

工厂方法是选择单个产品的实现，虽然一个类里面可以有多个工厂方法，但是这些方法之间一般是没有联系的，即使看起来像有联系。

但是抽象工厂着重的就是为一个产品簇选择实现，定义在抽象工厂里面的方法通常是有联系的，它们都是产品的某一部分或者是相互依赖的。如果抽象工厂里面只定义一个方法，直接创建产品，那么就退化成为工厂方法了。

2.何时选用抽象工厂模式

建议在以下情况中选用抽象工厂模式。

• 如果希望一个系统独立于它的产品的创建、组合和表示的时候。换句话说，希望一个系统只是知道产品的接口，而不关心实现的时候。
• 如果一个系统要由多个产品系列中的一个来配置的时候。换句话说，就是可以动态地切换产品簇的时候。
• 如果要强调一系列相关产品的接口，以便联合使用它们的时候。

3.实现

cpu产品

/**
 * @description:cpu接口
 */
public interface Cpu {

    /**
     * 初始化cpu
     */
    void initCpu();
}

/**
 * @description:英特尔cpu
 */
public class IntelCpu implements Cpu{
    //针脚
    private int pins=0;

    public IntelCpu(int pins){
        this.pins=pins;
    }

    @Override
    public void initCpu() {
        System.out.println("Cpu-->英特尔 针脚数"+pins);
    }
}

/**
 * @description:AMDcpu
 */
public class AmdCpu implements Cpu{

    private int pins=0;

    public AmdCpu(int pins){
        this.pins=pins;
    }

    @Override
    public void initCpu() {
        System.out.println("Cpu-->AMD 针脚数"+pins);
    }
}

主板接口

/**
 * @description:主板接口
 */
public interface Mainboard {

    /**
     * 初始化主板
     */
    void initMainBoard();
}

/**
 * @description:华硕主板
 */
public class AsusMainboard implements Mainboard{
    //针脚
    private int pins=0;

    public AsusMainboard(int pins){
        this.pins=pins;
    }

    @Override
    public void initMainBoard() {
        System.out.println("Mainboard-->华硕 针脚数"+pins);
    }
}

/**
 * @description:微星主板
 */
public class MsiMainboard implements Mainboard{

    private int pins=0;

    public MsiMainboard(int pins){
        this.pins=pins;
    }

    @Override
    public void initMainBoard() {
        System.out.println("Mainboard-->微星 针脚数"+pins);
    }
}

抽象工厂

/**
 * @description:抽象工厂
 */
public interface AbstractFactory {

    /**
     * 创建cpu
     * @return
     */
    Cpu createCpu();

    /**
     * 创建主板
     * @return
     */
    Mainboard createMainboard();
}

/**
 * @description:自组电脑1 (英特尔cpu+华硕主板) 假设都是1156针脚
 */
public class CustomComputer1 implements AbstractFactory{
    @Override
    public Cpu createCpu() {
        return new IntelCpu(1156);
    }

    @Override
    public Mainboard createMainboard() {
        return new AsusMainboard(1156);
    }
}

/**
 * @description:自组电脑2 (AMDcpu + 微星主板) 假设都是963针脚
 */
public class CustomComputer2 implements AbstractFactory{
    @Override
    public Cpu createCpu() {
        return new AmdCpu(963);
    }

    @Override
    public Mainboard createMainboard() {
        return new MsiMainboard(963);
    }
}

组装类

/**
 * @description:工程师组装电脑
 */
public class Engineer {

    /**
     * cpu
     */
    private Cpu cpu=null;

    /**
     * 主板
     */
    private Mainboard mainboard=null;

    /**
     * 组装电脑
     * @param factory
     */
    public void makeComputer(AbstractFactory factory){
        cpu=factory.createCpu();
        mainboard=factory.createMainboard();

        cpu.initCpu();
        mainboard.initMainBoard();
    }

}

测试

public class Client {

    public static void main(String[] args) {
        Engineer engineer = new Engineer();
        //顾客想组装的电脑配置
        engineer.makeComputer(new CustomComputer1());
    }
}

类图