首先我们先看一个场景，就是我们平常组装电脑，我们如果自己组装电脑，那么我们要买CPU，主板，内存条等等零件，但是因为他的可能有不同的型号，所以我们必须要买型号匹配的才可以，否则那肯定就有问题， 或者直接组装不上， 或者组装好之后会蓝屏啊死机啊什么的。当然也可以交给专业的人来组装，我们来看具体的实现：
定义CPU的接口：
public interface CPUApi {
void calculate();
}
定义主板的接口：
public interface MainboardApi {
void installCPC();
}
EntelCPU接口的实现：
public class IntelCPU implements CPUApi {
//针脚数
private int pins = 0;
public IntelCPU(int pins) {
this.pins = pins;
}
@Override
public void calculate() {
System.out.println("Intel CPU针脚数 = " + 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("AMD CPU 的针脚数" + pins);
}
}
微星主板的实现：
public class MSIMainboard implements MainboardApi {
//CPU插槽的孔数
private int cpuHoles = 0;
public MSIMainboard(int cpuHoles) {
this.cpuHoles = cpuHoles;
}
@Override
public void installCPC() {
System.out.println("微星主板 CPU插槽孔数： " + cpuHoles);
}
}
技嘉主板的实现：
public class GAMainboard implements MainboardApi {
//CPU插槽的孔数
private int cpuHoles = 0;
public GAMainboard(int cpuHoles) {
this.cpuHoles = cpuHoles;
}
@Override
public void installCPC() {
System.out.println("技嘉主板 CPU插槽孔数： " + cpuHoles);
}
}
CPU 工厂：
public class CPUFactory {
public static CPUApi createCPU(int type){
CPUApi cpuApi = null;
if(1 == type){
cpuApi = new IntelCPU(1156);
}else if(2 == type){
cpuApi = new AMDCPU(936);
}
return cpuApi;
}
}
主板工厂：
public class MainboardFactory {
public static MainboardApi createMainboard(int type){
MainboardApi api = null;
if(1 == type){
api = new GAMainboard(1156);
}else if(2 == type){
api = new MSIMainboard(936);
}
return api;
}
}
组装工程师：
public class ComputerEngineer {
private CPUApi cpu = null;
private MainboardApi mainboard = null;
public void makeComputer(int cpuType, int mainBoardType){
prepareHardware(cpuType, mainBoardType);
}
private void prepareHardware(int cpuType, int mainBoardType) {
cpu = CPUFactory.createCPU(cpuType);
mainboard = MainboardFactory.createMainboard(mainBoardType);
cpu.calculate();
mainboard.installCPC();
}
}
客户端：
public static void main(String[] args) {
ComputerEngineer engineer = new ComputerEngineer();
engineer.makeComputer(1, 1);
}
CPU针脚数 = 1156
技嘉主板 CPU插槽孔数： 1156
看上面多的代码很简单，但是这个是有问题的， 因为他没有考虑CPU和主板之间的依赖关系，如果传入的参数是1 和2 ，难么针脚数就完全对不上了，那就无法组装。针对这个问题，就是本小节的抽象工厂模式来解决
抽象工厂模式的定义： 提供一个创建系列相关或者相互依赖的对象的接口，而无需指定他们的具体实现类。
抽象工厂模式和工厂方法模式很像，如果不知道什么是抽象工厂模式，可以看上一篇博客
设计模式之工厂方法模式
抽象工厂模式针对的是一个产品族，而工厂方法模式针对的是一个产品。在抽象工厂模式里面，会定义一个抽象工厂，这个抽象工厂只是去定义一个个产品的api,并不去实现它，由的子类提供实现返回对象的产品，组成一个产品族，所以抽象工厂起到一个约束作用。
我们来看看组装电脑的抽象工厂的实现，CPU和主板的api和实现不用动：
抽象工厂：
public interface AbstractFactory {
CPUApi createCPU();
MainboardApi createMainBoard();
}
组装电脑的第一种实现：
public class Schema1 implements AbstractFactory {
@Override
public CPUApi createCPU() {
return new IntelCPU(1156);
}
@Override
public MainboardApi createMainBoard() {
return new GAMainboard(1156);
}
}
组装电脑的第2种实现：
public class Schema2 implements AbstractFactory {
@Override
public CPUApi createCPU() {
return new AMDCPU(929);
}
@Override
public MainboardApi createMainBoard() {
return new MSIMainboard(929);
}
}
再来看装机工程师，装机工程师里面不在需要CPU的主板的类型了，而是直接传入一个装机方案：
public class ComputerEngineer2 {
private CPUApi cpu = null;
private MainboardApi mainboard = null;
public void makeComputer(AbstractFactory factory){
prepareHardware(factory);
}
private void prepareHardware(AbstractFactory factory) {
cpu = factory.createCPU();
mainboard = factory.createMainBoard();
cpu.calculate();
mainboard.installCPC();
}
}
客户端：
public class Client1 {
public static void main(String[] args) {
Schema1 schema1 = new Schema1();
ComputerEngineer2 engineer2 = new ComputerEngineer2();
engineer2.makeComputer(schema1);
}
}
Intel CPU针脚数 = 1156
技嘉主板 CPU插槽孔数： 1156
在这种实现里面，CPU和主板是相关联的对象，抽象工厂就相当于一个装机方案，客户选择的时候，一选择就是一套，CPU和主板是确定好的，这就避免了不匹配的问题。
抽象工厂的优点是切换产品族很容易。 比如上面的scheme1代表一个产品，scheme2代表一个产品，客户远程不同的scheme就代表了不同的产品。
分离接口实现，客户端不知道具体的实现是谁，是哪个CPU还是哪个主板。
缺点也很明显，如果你要进行一个扩展的话，比如说你在加一个内存条，不仅要加内存条的api,内存条的实现，这些都不要紧，但是你必须得改抽象工厂，和每一个具体的产品，这就很尴尬了。
参考书籍： 设计模式
欢迎关注我的公众号： manong_xiaodong。 有大数据资料赠送哟，因为我最近也在学习大数据！欢迎一起学习
网友评论