设计模式 - 抽象工厂模式(Abstract Factory)

抽象工厂模式(Abstract Factory) 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

它可以看作是工厂方法模式(Factory Method)的扩展，相对于Factory Method创建一个对象， Abstract Factory 创建多个相关的对象。抽象工厂可以看做工厂方法的一个集合。

优点： 如果换产品系列，只需换相应的具体工厂即可； 客户代码与产品的具体实现分离。

缺点： 难以扩展新产品，如果要增加一个新产品，工厂的类层次中所有的工厂都要增加一个创建该产品的方法。

典型的使用场景：可以通过抽象工厂模式来创建一个产品的各个组件，创建产品的方法将抽象工厂作为参数，这样可以传递具体的工厂创建指定的各个组件的产品。

Abstract Factory与Builder相似，都可以创建复杂对象，主要的区别是Builder模式着重于一步步构造一个复杂对象。而Abstract Factory着重于多个系列的产品对象（简单的或是复杂的）。

示例： 如苹果电脑和华为电脑，它们各自使用自己的CPU，Memory 和 MainBoard.

接口	ComputerFactory	Cpu	Memory	MainBoard
实现类	AppleComputerFactory	AppleCpu	AppleMemory	AppleMainBoard
实现类	HuaweiComputerFactory	HuaweiCpu	HuaweiMemory	HuaweiMainBoard

//抽象工厂，提供了创建一系列产品的接口
public interface ComputerFactory {
    Computer createComputer();
    Cpu createCpu();
    Memory createMemory();
    MainBoard createMainBoard();
}
//具体工厂
public class AppleComputerFactory implements ComputerFactory {
    public Computer createComputer() {
        System.out.println("apple computer");
        return new Computer();
    }

    public Cpu createCpu() {
        return new AppleCpu();
    };
    public Memory createMemory() {
        return new AppleMemory();
    };
    public MainBoard createMainBoard() {
        return new AppleMainBoard();
    }
}
//具体工厂
public class HuaweiComputerFactory implements ComputerFactory {
    public Computer createComputer() {
        System.out.println("huawei computer");
        return new Computer();
    }
    public Cpu createCpu() {
        return new HuaweiCpu();
    };
    public Memory createMemory() {
        return new HuaweiMemory();
    };
    public MainBoard createMainBoard() {
        return new HuaweiMainBoard();
    }
}

//抽象产品
public abstract class Cpu {
}

public class AppleCpu extends Cpu {
}

public class HuaweiCpu extends Cpu {
}

//抽象产品
public abstract class Memory {
}

public class AppleMemory extends Memory {
}

public class HuaweiMemory extends Memory {
}

//抽象产品
public abstract class MainBoard {
}

public class AppleMainBoard extends  MainBoard {
}

public class HuaweiMainBoard extends  MainBoard {
}

public class Computer {
    private Cpu cpu;
    private Memory memory;
    private MainBoard mainBoard;
    public void setCpu(Cpu cpu) {
        this.cpu = cpu;
    }
    public void setMemory(Memory memory) {
        this.memory = memory;
    }
    public void setMainBoard(MainBoard mainBoard) {
        this.mainBoard = mainBoard;
    }
}

public class ComputerService {
    /** Cpu, Memory, MainBoard定义了Computer的各个组件的接口,
     配置一个ComputerFactory 抽象工厂来创建具体的各个组件对象，从而构建复杂的产品对象*/
    public Computer createComputer(ComputerFactory factory) {
        Computer computer = factory.createComputer();
        computer.setCpu(factory.createCpu());
        computer.setMemory(factory.createMemory());
        computer.setMainBoard(factory.createMainBoard());
        return computer;
    }

    public static void main(String[] args) {
        ComputerService computerService = new ComputerService();
        //AppleComputerFactory 具体工厂, 创建具体的AppleCpu, AppleMemory, 
        //AppleMemory组件来装配电脑
        ComputerFactory factory = new AppleComputerFactory();
        Computer computer = computerService.createComputer(factory);
        System.out.println(computer);
    }
}

返回 设计模式