研磨设计模式--抽象工厂模式

抽象工厂模式的定义：

提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类
demo：下面使用抽象工厂模式写一个简单的台式机装机的小程序
CPUApi：cpu的接口
MainboardApi：主板接口
AMDCpu：amd cpu
IntelCpu：intel cpu
MSIMainboard：微星主板
GAMMainboard：技嘉主板
Schema1：组合1
Schema2：组合2
ComputerEngineer：装机工程师的工具类
Client：客户端

/**
 * cpu的接口
 */
public interface CPUApi {
    /**
     * 示意方法具有运算功能
     */
    public void calculate();
}

/**
 * 主板接口
 */
public interface MainboardApi {
    /**
     * 示意方法，主办都具有安装cpu的功能
     */
    public void installCPU();
}

/**
 * intel cpu
 */
public class IntelCpu implements CPUApi {
    /**
     * cpu针脚数
     */
    private int pins = 0;

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

    @Override
    public void calculate() {
        System.out.println("now is intel cpu, pins = " + pins);
    }
}

/**
 * amd cpu
 */
public class AMDCpu implements CPUApi{
    private int pins = 0;

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

    @Override
    public void calculate() {
        System.out.println("now is amd cpu.pins = "  + pins);
    }
}

/**
 * 技嘉主板
 */
public class GAMMainboard implements MainboardApi {
    /**
     * cpu 插槽孔
     */
    private int cpuHoles = 0;

    public GAMMainboard(int cpuHoles) {
        this.cpuHoles = cpuHoles;
    }

    @Override
    public void installCPU() {
        System.out.println("now in gam mainboard, cpuHoles = " + cpuHoles);
    }
}

/**
 * 微星主板
 */
public class MSIMainboard implements MainboardApi{
    /**
     * cpu 插槽孔
     */
    private int cpuHoles = 0;

    public MSIMainboard(int cpuHoles) {
        this.cpuHoles = cpuHoles;
    }

    @Override
    public void installCPU() {
        System.out.println("now in msi mainboard, cpuHoles = " + cpuHoles);
    }
}

public class Schema1 implements AbstractFactory{
    @Override
    public CPUApi createCpuApi() {
        return new IntelCpu(1156);
    }

    @Override
    public MainboardApi createMainboardApi() {
        return new GAMMainboard(1156);
    }
}

public class Schema2 implements AbstractFactory{
    @Override
    public CPUApi createCpuApi() {
        return new AMDCpu(939);
    }

    @Override
    public MainboardApi createMainboardApi() {
        return new MSIMainboard(939);
    }
}

/**
 * 装机工程师的类
 */
public class ComputerEngineer {
    /**
     * 定义装配机器需要的cpu
     */
    private CPUApi cpu = null;
    /**
     * 定义装配机器需要的主板
     */
    private MainboardApi mainboardApi = null;

    /**
     * 装机过程
     * @param schema
     */
    public void makeComputer(AbstractFactory schema){
        prepardHardwares(schema);
    }

    /**
     * 装机准备所需要的配件
     * @param schema
     */
    public void prepardHardwares(AbstractFactory schema){
        this.cpu = schema.createCpuApi();
        this.mainboardApi = schema.createMainboardApi();
        this.cpu.calculate();
        this.mainboardApi.installCPU();
    }


}

public class Client {
    public static void main(String[] args) {
        ComputerEngineer engineer = new ComputerEngineer();
        AbstractFactory schema = new Schema1();
        engineer.makeComputer(schema);
    }
}

抽象工厂模式的功能：

抽象工厂模式的功能是为了一系列相关对象或相互依赖的对象创建一个接口。从某种意义上讲，抽象工厂其实是一个产品系列，或者是产品簇。

抽象工厂模式的优点：

分离接口和实现
使得切换产品簇变得更加容易

抽象工厂模式的缺点：

不太容易扩展新的产品
容易造成类层次复杂