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

Posted 2021-01-28 yangyongxin

抽象工厂模式简介：

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

     这里讲解一下产品等级与产品族：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);
    }
}

View Code

       组装工程师代码与之前的主要区别是：现在不在需要客户传入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(Class<?> c) {
        AbstractFactory factory=null;
        try {
             factory=(AbstractFactory) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        cpu=factory.createCpu();
        mainboard=factory.createMainboard();
        cpu.calculate();
        mainboard.installCpu();
        System.out.println("电脑组装完成");
    }
}

View Code

      客户端代码：

package com.itheima.factory.client;

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

public class Client {
    public static void main(String[] args) {
        ComputerEngineer computerEngineer = new ComputerEngineer();
        computerEngineer.makeComputer(IntelFactory.class);
    }
}

View Code

抽象工厂的功能是为一系列相关对象或相互依赖的对象（跨产品等级）创建一个接口。一定注意接口内的方法不是任意堆砌的，而是一系列相关的或相互依赖的方法。