2.java设计模式抽象工厂模式

抽象工厂模式简介：

      每一个模式都是针对某一种问题的解决方案。抽象工厂模式与工厂模式最大的区别在于，工厂模式针对的是一个产品等级结构，而抽象工厂模式面对的是多个产品等级结构，即产品族的概念。

     这里讲解一下产品等级与产品族：Cpu属于一种产品，Cpu有多种型号，比如Intel的、AMD的，它们都属于同一个产品等级，即同一类产品下边的不同系列或者品牌；而产品族是指位于不同产品等级结构中，功能相关联的产品组成的家族。比如对于Intel公司，这家公司生产的Cpu，也生产主板，内存，芯片组等相关联产品组成一个产品族。所以我们只要知道某个产品所属的产品族，以及这个产品在产品族中的产品等级结构，就可以唯一确定这个产品。

    显然，每一个产品族中含有产品的数目，与产品等级结构的数目是相等的。而在工厂模式中，需要创建的工厂类数量等于产品等级结构数目。由于这三个产品等级结构的相似性，会导致三个平行的工厂等级结构。随着产品等级结构的数目的增加，工厂方法模式所给出的工厂等级结构的数目也会随之增加。如下图：

造成大量重复性代码，这样违背了软件设计初衷。

那么是否可以将这些极为相似的产品等级工厂代码用同一个产品等级工厂代替呢？当然可以，这就是产品族的概念，之前是纵向构建了多个产品等级工厂，那么我们改为横向的使用产品族来构建一个产品族工厂，这个与我们现实世界的工厂更为相似。如图：

显然，这种工厂模式更有效率。

抽象工厂模式详解：

     抽象工厂模式是对象的创建模式，它是工厂模式的进一步推广。假设一个子系统需要多个产品对象，而这些产品对象又不处于同一个产品等级，为了将消费这些产品对象的责任与创建这些产品对象的责任分隔开，可以引入抽象工厂模式。这样消费产品的一方不必参与产品的创建工作，只需要向一个工厂接口请求生产产品即可。

    由于上述两个产品族的产品等级结构相同，所以可以继续将两个产品族抽象为同一个工厂族，这就是抽象工厂概念。

源代码：

       前面示例实现的CPU接口和CPU实现对象，主板接口和主板实现对象，都不需要变化。

　　工厂类需要全部重写，新加入的抽象工厂类和实现类：

package com.itheima.factory.factory;

import com.itheima.factory.entity.CPU;
import com.itheima.factory.entity.Mainboard;
/**
 * 抽象工厂类，定义规范
 * @author Administrator
 *
 */
public interface AbstractFactory {
    /**
     * 创建CPU
     * @return
     */
    public CPU createCpu();
    /**
     * 创建主板对象
     * @return
     */
    public Mainboard createMainboard();
}

//具体的实现类工厂
package com.itheima.factory.factory;

import com.itheima.factory.entity.CPU;
import com.itheima.factory.entity.IntelCpu;
import com.itheima.factory.entity.IntelMainboard;
import com.itheima.factory.entity.Mainboard;
/**
 * Intel工厂
 * @author Administrator
 *
 */
public class IntelFactory implements AbstractFactory {
    @Override
    public CPU createCpu() {
        // TODO Auto-generated method stub
        return new IntelCpu(755);
    }
    @Override
    public Mainboard createMainboard() {
        // TODO Auto-generated method stub
        return new IntelMainboard(755);
    }
}

package com.itheima.factory.factory;

import com.itheima.factory.entity.AmdCpu;
import com.itheima.factory.entity.AmdMainboard;
import com.itheima.factory.entity.CPU;
import com.itheima.factory.entity.Mainboard;
/**
 * AMD工厂
 * @author Administrator
 *
 */
public class AmdFactory implements AbstractFactory {

    @Override
    public CPU createCpu() {
        // TODO Auto-generated method stub
        return new AmdCpu(938);
    }
    @Override
    public Mainboard createMainboard() {
        // TODO Auto-generated method stub
        return new AmdMainboard(938);
    }
}

       组装工程师代码与之前的主要区别是：现在不在需要客户传入Cpu与主板的类型，而是直接传入已经选择后的产品对象，且产品对象已经被限制，客户无法选择Intel与Amd的组合了。客户要选就是一套，一个组合。

package com.itheima.factory.engineer;

import com.itheima.factory.entity.CPU;
import com.itheima.factory.entity.Mainboard;
import com.itheima.factory.factory.AbstractFactory;

public class ComputerEngineer {
    //需要Cpu
    private CPU cpu;
    //需要主板
    private Mainboard mainboard;
    //组装电脑
    public void makeComputer(AbstractFactory af) {    
        cpu=af.createCpu();
        mainboard=af.createMainboard();
        cpu.calculate();
        mainboard.installCpu();
        System.out.println("电脑组装完成");
    }
}

      客户端代码：

package com.itheima.factory.client;

import com.itheima.factory.engineer.ComputerEngineer;
import com.itheima.factory.factory.AbstractFactory;
import com.itheima.factory.factory.IntelFactory;

public class Client {
    public static void main(String[] args) {
        //创建装机工程师对象
        ComputerEngineer computerEngineer = new ComputerEngineer();
        //客户选择从并创建相应的产品对象
        AbstractFactory af=new IntelFactory();
        computerEngineer.makeComputer(af);
    }
}

       抽象工厂的功能是为一系列相关对象或相互依赖的对象（跨产品等级）创建一个接口。一定注意接口内的方法不是任意堆砌的，而是一系列相关的或相互依赖的方法。比如上面例子中的主板和CPU，都是为了组装一台电脑的相关对象。不同的装机方案，代表一种具体的电脑系列。

       由于抽象工厂定义的一系列对象通常是相关或相互依赖的，这些产品对象就构成了一个产品族，也就是抽象工厂定义了一个产品族。这就带来非常大的灵活性，切换产品族的时候，只要提供不同的抽象工厂实现就可以了，也就是说现在是以一个产品族作为一个整体被切换。

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

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

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

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

　　4.系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。