publicinterface Cpu {
publicvoid calculate();
}

publicclass IntelCpu implements Cpu {
/**
     * CPU的针脚数
*/
privateint pins = 0;
public  IntelCpu(int pins){
this.pins = pins;
    }
    @Override
publicvoid calculate() {
        System.out.println("Intel CPU的针脚数：" + pins);
    }
}

publicclass AmdCpu implements Cpu {
privateint pins = 0;
public  AmdCpu(int pins){
this.pins = pins;
    }
    @Override
publicvoid calculate() {
        System.out.println("AMD CPU的针脚数：" + pins);
    }
}

publicinterface Mainboard {
publicvoid installCPU();
}

publicclass IntelMainboard implements Mainboard {
/**
     * CPU插槽的孔数
*/
privateint cpuHoles = 0;
// 构造方法，传入CPU插槽的孔数
public IntelMainboard(int cpuHoles){
this.cpuHoles = cpuHoles;
    }
    @Override
publicvoid installCPU() {
        System.out.println("Intel主板的CPU插槽孔数是：" + cpuHoles);
    }
}

publicclass AmdMainboard implements Mainboard {
privateint cpuHoles = 0;
    //构造方法，传入CPU插槽的孔数
public AmdMainboard(int cpuHoles){
this.cpuHoles = cpuHoles;
    }
    @Override
publicvoid installCPU() {
        System.out.println("AMD主板的CPU插槽孔数是：" + cpuHoles);
    }
}

publicclass CpuFactory {
publicstatic Cpu createCpu(int type){
        Cpu cpu = null;
if(type == 1){
            cpu = new IntelCpu(755);
        }elseif(type == 2){
            cpu = new AmdCpu(938);
        }
return cpu;
    }
}

publicclass MainboardFactory {
publicstatic Mainboard createMainboard(int type){
        Mainboard mainboard = null;
if(type == 1){
            mainboard = new IntelMainboard(755);
        }elseif(type == 2){
            mainboard = new AmdMainboard(938);
        }
return mainboard;
    }
}

publicclass ComputerEngineer {
    //定义组装机须要的CPU
private Cpu cpu = null;
    //定义组装机须要的主板
private Mainboard mainboard = null;
publicvoid makeComputer(int cpuType , int mainboard){
/**
         * 组装机器的基本步骤
*/
//1:首先准备好装机所须要的配件
        prepareHardwares(cpuType, mainboard);
//2:组装机器
//3:測试机器
//4：交付客户
    }
privatevoid prepareHardwares(int cpuType , int mainboard){
//这里要去准备CPU和主板的详细实现。为了演示样例简单。这里仅仅准备这两个
//但是，装机project师并不知道怎样去创建，怎么办呢？
//直接找对应的工厂获取
this.cpu = CpuFactory.createCpu(cpuType);
this.mainboard = MainboardFactory.createMainboard(mainboard);
//測试配件是否好用
this.cpu.calculate();
this.mainboard.installCPU();
    }
}

publicclass Client {
publicstaticvoid main(String[]args){
        ComputerEngineer cf = new ComputerEngineer();
        cf.makeComputer(1,1);
    }
}

引进抽象工厂模式

　　能够看出。一个工厂等级结构能够创建出分属于不同产品等级结构的一个产品族中的全部对象。显然，这时候抽象工厂模式比简单工厂模式、工厂方法模式更有效率。相应于每个产品族都有一个详细工厂。

而每个详细工厂负责创建属于同一个产品族，可是分属于不同等级结构的产品。

抽象工厂模式结构

　　抽象工厂模式是对象的创建模式。它是工厂方法模式的进一步推广。

　　如果一个子系统须要一些产品对象，而这些产品又属于一个以上的产品等级结构。

那么为了将消费这些产品对象的责任和创建这些产品对象的责任切割开来，能够引进抽象工厂模式。这种话。消费产品的一方不须要直接參与产品的创建工作，而仅仅须要向一个公用的工厂接口请求所须要的产品。

　　通过使用抽象工厂模式。能够处理具有同样（或者相似）等级结构中的多个产品族中的产品对象的创建问题。

例如以下图所看到的：

　　因为这两个产品族的等级结构同样。因此使用同一个工厂族也能够处理这两个产品族的创建问题。这就是抽象工厂模式。

　　依据产品角色的结构图。就不难给出工厂角色的结构设计图。

　　能够看出。每个工厂角色都有两个工厂方法，分别负责创建分属不同产品等级结构的产品对象。下图ComputerEngineer依赖于AbstractFactory、Cpu和MainBoard三个接口。

源码

publicinterface AbstractFactory {
/**
     * 创建CPU对象
*/
public Cpu createCpu();
/**
     * 创建主板对象
*/
public Mainboard createMainboard();
}

publicclass IntelFactory implements AbstractFactory {
    @Override
public Cpu createCpu() {
returnnew IntelCpu(755);
    }
    @Override
public Mainboard createMainboard() {
returnnew IntelMainboard(755);
    }
}

publicclass AmdFactory implements AbstractFactory {
    @Override
public Cpu createCpu() {
returnnew IntelCpu(938);
    }
    @Override
public Mainboard createMainboard() {
returnnew IntelMainboard(938);
    }
}

　　装机project师类跟前面的实现相比，基本的变化是：从client不再传入选择CPU和主板的參数，而是直接传入客户已经选择好的产品对象。

这样就避免了单独去选择CPU和主板所带来的兼容性问题，客户要选就是一套。就是一个系列。

publicclass ComputerEngineer {
private Cpu cpu = null;
private Mainboard mainboard = null;
publicvoid makeComputer(AbstractFactory af){
        prepareHardwares(af);
    }
privatevoid prepareHardwares(AbstractFactory af){
this.cpu = af.createCpu();
this.mainboard = af.createMainboard();
this.cpu.calculate();
this.mainboard.installCPU();
    }
}

client代码：

publicclass Client {
publicstaticvoid main(String[]args){
//创建装机project师对象
        ComputerEngineer cf = new ComputerEngineer();
//客户选择并创建须要使用的产品对象
        AbstractFactory af = new IntelFactory();
//告诉装机project师自己选择的产品，让装机project师组装电脑
        cf.makeComputer(af);
    }
}

　　抽象工厂的功能是为一系列相关对象或相互依赖的对象创建一个接口。一定要注意，这个接口内的方法不是随意堆砌的。而是一系列相关或相互依赖的方法。

比方上面样例中的主板和CPU。都是为了组装一台电脑的相关对象。不同的装机方案，代表一种详细的电脑系列。

　　因为抽象工厂定义的一系列对象一般是相关或相互依赖的，这些产品对象就构成了一个产品族。也就是抽象工厂定义了一个产品族。

这就带来很大的灵活性。切换产品族的时候。仅仅要提供不同的抽象工厂实现就能够了。也就是说如今是以一个产品族作为一个总体被切换。

在什么情况下应当使用抽象工厂模式

　　1.一个系统不应当依赖于产品类实例怎样被创建、组合和表达的细节，这对于全部形态的工厂模式都是重要的。

2.这个系统的产品有多于一个的产品族，而系统仅仅消费当中某一族的产品。

3.同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。（比方：Intel主板必须使用Intel CPU、Intel芯片组）

4.系统提供一个产品类的库。全部的产品以相同的接口出现，从而使client不依赖于实现。

抽象工厂模式的起源

　　抽象工厂模式的起源或者最早的应用，是用于创建分属于不同操作系统的视窗构建。

比方：命令按键（Button）与文字框(Text)都是视窗构建，在UNIX操作系统的视窗环境和Windows操作系统的视窗环境中，这两个构建有不同的本地实现，它们的细节有所不同。

　　在每个操作系统中，都有一个视窗构建组成的构建家族。在这里就是Button和Text组成的产品族。而每个视窗构件都构成自己的等级结构，由一个抽象角色给出抽象的功能描写叙述，而由详细子类给出不同操作系统下的详细实现。

　　能够发如今上面的产品类图中，有两个产品的等级结构，各自是Button等级结构和Text等级结构。同一时候有两个产品族。也就是UNIX产品族和Windows产品族。

UNIX产品族由UNIX Button和UNIX Text产品构成；而Windows产品族由Windows Button和Windows Text产品构成。

　　　　系统对产品对象的创建需求由一个project的等级结构满足。当中有两个详细project角色，即UnixFactory和WindowsFactory。UnixFactory对象负责创建Unix产品族中的产品，而WindowsFactory对象负责创建Windows产品族中的产品。这就是抽象工厂模式的应用，抽象工厂模式的解决方式例如以下图：

　　显然，一个系统仅仅可以在某一个操作系统的视窗环境下执行，而不能同一时候在不同的操作系统上执行。

所以。系统实际上仅仅能消费属于同一个产品族的产品。

　　在现代的应用中，抽象工厂模式的使用范围已经大大扩大了，不再要求系统仅仅能消费某一个产品族了。因此。能够不必理会前面所提到的原始用意。

抽象工厂模式的长处

• 分离接口和实现

　　client使用抽象工厂来创建须要的对象，而client根本就不知道详细的实现是谁，client仅仅是面向产品的接口编程而已。也就是说。client从详细的产品实现中解耦。

• 使切换产品族变得easy

　　由于一个详细的工厂实现代表的是一个产品族，比方上面样例的从Intel系列到AMD系列仅仅须要切换一下详细工厂。

• 添加产品族变的easy

　　假设出现新的产品族，仅仅需新增抽象工厂的一个实现类用于处理新产品族，其他实现类都不需改变、

抽象工厂模式的缺点

• 不太easy扩展新的产品（不是产品族，而是产品等级，如显卡）

　　假设须要给整个产品族加入一个新的产品，那么就须要改动抽象工厂，这样就会导致改动全部的工厂实现类。