设计模式（6）- 抽象工厂模式

抽象工厂模式

1.定义

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

2.示例代码

       比如组装机器的时候，cpu和主板可以看作两个对象，这两个对象相互依赖，cpu针脚必须和主板针槽相匹配。

    

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

/*intel CPU实现*/
public class IntelCPU implements CPUApi{
     //CPU针脚数目
     private int pins = 0;
     //构造方法传入针脚数
     public IntelCPU(int pins){
         this.pins = pins;
     }
     public void calculate(){
          System.out.pringln("now in Intel CPU,pins = " + pins);
     }
}

/*AMD CPU实现*/
public class AMDCPU implements CPUApi{
     //CPU针脚数目
     private int pins = 0;
     //构造方法传入针脚数
     public AMDCPU(int pins){
         this.pins = pins;
     }
     public void calculate(){
          System.out.pringln("now in AMD CPU,pins = " + pins);
     }
}

   

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

/*技嘉主板实现*/
public class GAMainboard implements MainboardApi{
    //cpu 针槽孔数
    private int cpuHoles = 0;
    //构造方法传入cpu针槽孔数
    public GAMainboard(int cpuHoles){
        this.cpuHoles = cpuHoles;
    }
    public void installCPU(){
        System.out.println("now in GAMainboard,cupHoles = " + cpuHoles);
    }
}

/*微星主板实现*/
public class MSIMainboard implements MainboardApi{
    //cpu 针槽孔数
    private int cpuHoles = 0;
    //构造方法传入cpu针槽孔数
    public MSIMainboard(int cpuHoles){
        this.cpuHoles = cpuHoles;
    }
    public void installCPU(){
        System.out.println("now in MSIMainboard,cupHoles = " + cpuHoles);
    }
}

   

/*抽象工厂接口，声明创建抽象产品对象的操作*/
public interface AbstractFactory{
    //创建cpu对象
    public CPUApi createCPUApi();
    //创建主板对象
    public MainboardApi createMainboardApi();
}

/*抽象工厂的实现，具体的装机方案1：方案对象 Intel的CPU + 技嘉的主板*/
public class Schema1 implements AbstractFactory{
   //创建Intel的cpu对象
    public CPUApi createCPUApi(){
        return new IntelCUP(1156);
    }
    //创建技嘉主板对象
    public MainboardApi createMainboardApi(){
        return new GMMainboard(1156);
    }
}

/*抽象工厂的实现，具体的装机方案2：方案对象 AMD的CPU + 微星的主板*/
public class Schema2 implements AbstractFactory{
   //创建AMD的cpu对象
    public CPUApi createCPUApi(){
        return new AMDCUP(939);
    }
    //创建技嘉主板对象
    public MainboardApi createMainboardApi(){
        return new MSIMainboard(939);
    }
}

   

/*装机工程师类*/
public class ComputerEngineer{
    //定义组装电脑需要的cpu
    private CPUApi cpu = null;
    //定义所需要的主板
    private MainboardApi  mainboard = null;
    //装机过程，客户选择的装机方案
    public void makeComputer(AbstractFactory schema){
         //准备装机所需配件
         prepareHardwares(schema);
    } 
    //装机所需配件，客户选择的装机方案
    private void prepareHardwares(AbstractFactory schema){
         this.cpu = schema.createCPUApi();
         this.mainboard = schema.createMainboardApi();
         //测试配件是否匹配
         this.cpu.calculate();
         this.mainboard.installCPU();
    }
}

   

/*客户组装机器*/
public class Client{
    public static void main(String args[]){
       //创建装机工程师对象
       ComputerEngineer engineer = new  ComputerEngineer();
       //客户选择并创建需要使用的装机方案对象
       AbstractFactory schema = new Schema1();
       //告诉装机工程师所选的方案
       engineer.makeComputer(schema);
    }
}

 

    

    3.实际应用

       抽象工厂的功能是为一系列相关对象或相互依赖的对象创建的一个接口，需要注意的是这个接口内的方法不是任意堆砌的，而是一系列相关或相互依赖的方法，抽象工厂其实是一个产品系列或者是产品簇。抽象工厂的优点是分离接口和实现，缺点是容易造成类层次复杂，不容易扩展新的产品。

 

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