抽象工厂模式

                              抽象工厂            Abstract Factory

1.   定义:   提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类.

2.   使用抽象工厂来解决问题的思路:

一个是只知道所需要的一系列对象的接口,而不知道具体的实现,或者是不知道具体使用哪一个实现;另外一个是这一系列对象是相关或者相互依赖的即既要创建接口的对象,还要约束他们之间的关系.

注意:这里要解决的问题与简单工厂和工厂方法模式解决的问题有很大的不同,简单工厂和工厂方法模式关注的是单个产品的创建,而抽象工厂要解决的问题时要创建一系列的产品对象,而且这一系列对象是构件新的对象所需要的组成部分,也就是这一系列被创建的对象相互之间是由约束的.

在抽象工厂里,会定义一个抽象工厂,在里面虚拟的创建客户端需要的这一系列对象,所谓虚拟的就是定义创建这些对象的抽象方法,并不真正去实现,然后又具体的抽象工厂的子类来提供这一系列对象的创建.这样一来可以为同一个抽象工厂提供很多不同的实现,那么创建的这一系列对象也就不一样,也就是说,抽象工厂在这里起到一个约束的作用,并提供所有紫烈的一个统一的外观,来让客户端使用.

3.   实例代码

package pattern.abstractfactory.product;

/**

 * CPU接口

 * @authorAdministrator

*/

public interface CPU {

       publicvoid calculate();

}

 

package pattern.abstractfactory.product;

 

/**

 * 主板类接口

 * @authorAdministrator

*/

public interface MainBoard {

       //示意方法,安装CPU

       publicvoid installCPU();

}

 

package pattern.abstractfactory.product;

 

/**

 * AMDCPU

 * @authorAdministrator

 *

 */

public class AMDCPU implements CPU {

       //针脚数

       privateint pins = 0;

      

       /**

        *构造方法

        * @param pins针脚数

        */

       publicAMDCPU(int pins){

              this.pins= pins;

       }

       publicvoid calculate() {

       System.out.println("AMDCPU calculate() " + pins);  

       }

}

package pattern.abstractfactory.product;

 

/**

 * IntelCPU

 * @authorAdministrator

 *

 */

public class IntelCPU implements CPU {

 

       //针脚数

       privateint pins = 0;

      

       /**

        *构造方法

        * @param pins针脚数

        */

       publicIntelCPU(int pins){

              this.pins= pins;

       }

      

       publicvoid calculate() {

      System.out.println("IntellCPU calculate() " + pins);

       }

}

 

package pattern.abstractfactory.product;

 

/**

 * 技嘉主板

 * @authorAdministrator

 *

 */

public class GAMainboard implements MainBoard {

       //插槽数

       privateint cpuHoles = 0;

       /**

        *构造方法

        * @param pins插槽数

        */

       publicGAMainboard(int cpuHoles) {

              this.cpuHoles= cpuHoles;

       }

       publicvoid installCPU() {

       System.out.println("GAMainboard installCPU() " +cpuHoles);  

       }

}

 

package pattern.abstractfactory.product;

 

/**

 * 微星主板

 * @authorAdministrator

 *

 */

public class MISMainboard implements MainBoard {

 

       //插槽数

    private intcpuHoles = 0;

    /**

     * 构造方法

     * @parampins插槽数

     */

       publicMISMainboard(int cpuHoles) {

              this.cpuHoles= cpuHoles;

       }

       publicvoid installCPU() {

       System.out.println("MISMainboard installCPU() " +cpuHoles);  

       }

}

 

package pattern.abstractfactory.factory;

 

import pattern.abstractfactory.product.CPU;

import pattern.abstractfactory.product.MainBoard;

 

/**

 * 抽象工厂(实质:实现一系列产品,为一些有关联或相互依赖的对象提供接口)

 * @authorAdministrator

 *

 */

public interface AbstractFactory {

 

       //制造CPU

       public CPUcreateCPU();

      

       //制造主板

       publicMainBoard createMainboard();

      

}

 

 

package pattern.abstractfactory.factory;

 

import pattern.abstractfactory.product.CPU;

import pattern.abstractfactory.product.GAMainboard;

import pattern.abstractfactory.product.IntelCPU;

import pattern.abstractfactory.product.MainBoard;

 

/**

 * 方案一:IntelCPU + 技嘉主板

 * @authorAdministrator

 *

 */

public class Shema1 implements AbstractFactory {

 

       public CPUcreateCPU() {

              returnnew IntelCPU(1156);

       }

 

       publicMainBoard createMainboard() {

              returnnew GAMainboard(1156);

       }

 

}

 

 

package pattern.abstractfactory.factory;

 

import pattern.abstractfactory.product.AMDCPU;

import pattern.abstractfactory.product.CPU;

import pattern.abstractfactory.product.MISMainboard;

import pattern.abstractfactory.product.MainBoard;

 

/**

 * 方案二:AMDCPU + 微星主板

 * @authorAdministrator

 *

 */

public class Shema2 implements AbstractFactory {

 

       public CPUcreateCPU() {

              returnnew AMDCPU(939);

       }

 

       publicMainBoard createMainboard() {

              returnnew MISMainboard(939);

       }

 

}

 

 

 

package pattern.abstractfactory.factory;

 

import pattern.abstractfactory.product.CPU;

import pattern.abstractfactory.product.MainBoard;

 

/**

 * 装机工程师

 * @authorAdministrator

 *

 */

public class ComputerEngineer {

 

       privateCPU cpu = null;

       privateMainBoard mainboard = null;

   

       /**

        *装配电脑

        * @param shema具体方案

        */

       publicvoid makeComputer(AbstractFactory shema){

        //安装CPU和主板

              this.cpu= shema.createCPU();

       this.mainboard = shema.createMainboard();

       

        //测试相关的功能

       cpu.calculate();

       mainboard.installCPU();

       }

}

 

 

 

package pattern.abstractfactory.client;

 

importpattern.abstractfactory.factory.AbstractFactory;

importpattern.abstractfactory.factory.ComputerEngineer;

import pattern.abstractfactory.factory.Shema1;

 

/**

 * 客户端

 * @authorAdministrator

 *

 */

public class Client {

 

       publicstatic void main(String[] args) {

          

              ComputerEngineerengineer = new ComputerEngineer();

          

           AbstractFactory shema = new Shema1();

          

           engineer.makeComputer(shema);

          

       }

}

 

 

在组装电脑的时候,CPU和主板之间根据插槽数和针脚数来相互约束,如方案一和方案二….即相互之间是由约束的.