本文共 5424 字，大约阅读时间需要 18 分钟。

场景：配电脑，多种CPU、主板

1. 正常编码

1.1 cpu

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

IntelCPU:

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

AMDCPU:

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

1.2 主板

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

技嘉主板

public class GAMainboard implements MainboardApi {    	private int cpuHoles = 0;// CPU插槽的孔数  	public GAMainboard(int cpuHoles){   	//构造方法，传入CPU插槽的孔数		this.cpuHoles = cpuHoles;	}	public void installCPU() {   		System.out.println("now in GAMainboard,cpuHoles="+cpuHoles);	}}

微星主板

public class MSIMainboard implements MainboardApi{    	private int cpuHoles = 0;	//CPU插槽的孔数  	//构造方法，传入CPU插槽的孔数 	public MSIMainboard(int cpuHoles){   		this.cpuHoles = cpuHoles;	}	public void installCPU() {   		System.out.println("now in MSIMainboard,cpuHoles="+cpuHoles);	}}

1.3 创建CPU和主板的工厂：

//创建CPU的简单工厂 public class CPUFactory {   	//创建CPU接口对象的方法 	public static CPUApi createCPUApi(int type){   		CPUApi cpu = null;		//根据参数来选择并创建相应的CPU对象		if(type==1){   			cpu = new IntelCPU(1156);		}else if(type==2){   			cpu = new AMDCPU(939);		}		return cpu;	}	} //创建主板的简单工厂 public class MainboardFactory {   	//创建主板接口对象的方法 	public static MainboardApi createMainboardApi(int type){   		MainboardApi mainboard = null;		//根据参数来选择并创建相应的主板对象		if(type==1){   			mainboard = new GAMainboard(1156);		}else if(type==2){   			mainboard = new MSIMainboard(939);		}		return mainboard;	}}

1.4 工程师

public  class ComputerEngineer {    	private CPUApi cpu= null;//定义组装机器需要的CPU 	private MainboardApi mainboard = null;//定义组装机器需要的主板	//装机过程 	public void makeComputer(int cpuType,int mainboardType){   		//1：首先准备好装机所需要的配件		prepareHardwares(cpuType,mainboardType);		//2：组装机器 		//3：测试机器 		//4：交付客户	}	//准备装机所需要的配件 	private void prepareHardwares(int cpuType,int mainboardType){   		//这里要去准备CPU和主板的具体实现，为了示例简单，这里只准备这两个		//可是，装机工程师并不知道如何去创建，怎么办呢？				//直接找相应的工厂获取		this.cpu = CPUFactory.createCPUApi(cpuType);		this.mainboard = MainboardFactory.createMainboardApi(mainboardType);				//测试一下配件是否好用		this.cpu.calculate();		this.mainboard.installCPU();	}}

client:

public static void main(String[] args) {   		//创建装机工程师对象		ComputerEngineer engineer = new ComputerEngineer();		//告诉装机工程师自己选择的配件，让装机工程师组装电脑		engineer.makeComputer(1,2);	}

2. 运用抽象工厂模式

• 定义了一个产品族

比如有2种主板、2种cpu，然后按照工厂模式，可以为create(MainBoardType, CPUType ), 但是现在主板和cpu必须配套。因此有主题。

//抽象工厂的接口，声明创建抽象产品对象的操作 public interface AbstractFactory {   	//示例方法，创建抽象产品A的对象 	public AbstractProductA createProductA();	//示例方法，创建抽象产品B的对象 	public AbstractProductB createProductB();}

public class Schema1 implements AbstractFactory{   	public CPUApi createCPUApi() {   		return new IntelCPU(1156);	}	public MainboardApi createMainboardApi() {   		return new GAMainboard(1156);	}	}

//装机工程师的类 public  class ComputerEngineer {    	private CPUApi cpu= null;//定义组装机器需要的CPU 	private MainboardApi mainboard = null;// 定义组装机器需要的主板 	public void makeComputer(AbstractFactory schema){   //装机过程		//1：首先准备好装机所需要的配件		prepareHardwares(schema);		//2：组装机器				//3：测试机器				//4：交付客户	}		//准备装机所需要的配件 	private void prepareHardwares(AbstractFactory schema){   		//这里要去准备CPU和主板的具体实现，为了示例简单，这里只准备这两个		//可是，装机工程师并不知道如何去创建，怎么办呢？				//使用抽象工厂来获取相应的接口对象		this.cpu = schema.createCPUApi();		this.mainboard = schema.createMainboardApi();				//测试一下配件是否好用		this.cpu.calculate();		this.mainboard.installCPU();	}}

2. 新增加内存的使用

public class Schema1 implements AbstractFactory{   	public Object createProduct(int type) {   		Object retObj = null;		//type为1表示创建CPU，type为2表示创建主板		if(type==1){   			retObj = new IntelCPU(1156);		}else if(type==2){   			retObj = new GAMainboard(1156);		}		return retObj;	}	}public class Schema3 implements AbstractFactory{   	public Object createProduct(int type) {   		Object retObj = null;		//type为1表示创建CPU，type为2表示创建主板，type为3表示创建内存		if(type==1){   			retObj = new IntelCPU(1156);		}else if(type==2){   			retObj = new GAMainboard(1156);		}		//创建新添加的产品		else if(type==3){   			retObj = new HyMemory();		}		return retObj;	}}

调用处：

public class ComputerEngineer {

private CPUApi cpu= null;//定义组装机器需要的CPU private MainboardApi mainboard = null; //定义组装机器需要的主板 private MemoryApi memory = null; //定义组装机器需要的内存 //装机过程 public void makeComputer(AbstractFactory schema){ //1：首先准备好装机所需要的配件 prepareHardwares(schema); //2：组装机器

//3：测试机器		//4：交付客户}//准备装机所需要的配件 private void prepareHardwares(AbstractFactory schema){	//这里要去准备CPU和主板的具体实现，为了示例简单，这里只准备这两个	//可是，装机工程师并不知道如何去创建，怎么办呢？		//使用抽象工厂来获取相应的接口对象	this.cpu = (CPUApi)schema.createProduct(1);	this.mainboard = (MainboardApi)schema.createProduct(2);	this.memory = (MemoryApi)schema.createProduct(3);		//测试一下配件是否好用	this.cpu.calculate();	this.mainboard.installCPU();	if(memory!=null){		this.memory.cacheData();	}}

}

public static void main(String[] args) {

//创建装机工程师对象 ComputerEngineer engineer = new ComputerEngineer(); //客户选择并创建需要使用的装机方案对象 AbstractFactory schema = new Schema3(); //告诉装机工程师自己选择的装机方案，让装机工程师组装电脑 engineer.makeComputer(schema); }

3. 总结

比较灵活，但是还是不安全。

优缺点： 优点：切换产品族容易。 缺点：容易造成类层次复杂。比如技嘉主板又分好几种，难度又要增加几个类。

转载地址：http://gvq.baihongyu.com/