抽象工厂模式

抽象工厂模式

通过一个接口创建一系列相关的对象，而不需要指定具体的类（由工厂完成）

注意，工厂模式是is-else，而抽象工厂是根据输入工厂类返回子类。

• “工厂中的工厂”，可以看做是一个层级结构的“平台”，很多“商家”，提供很多“商品”。
• 抽象工厂干着单例的事情
• 扩展性好于工厂模式，避免条件判断，但复杂度也增加

代码如下：EmberToolkit和EnginolaToolkit是两个工厂类，从AbstractFactory这个抽象工厂类中初始化。

// class CPU
abstract class CPU {
}
class EmberCPU extends CPU {
}
class EnginolaCPU extends CPU {
}

// class MMU
abstract class MMU {
}
class EmberMMU extends MMU {
}
class EnginolaMMU extends MMU {
}

// factory EmberFactory
class EmberToolkit extends AbstractFactory {
    @Override
    public CPU createCPU() {
        return new EmberCPU();
    }

    @Override
    public MMU createMMU() {
        return new EmberMMU();
    }
}

// factory Enginola
class EnginolaToolkit extends AbstractFactory {
    @Override
    public CPU createCPU() {
        return new EnginolaCPU();
    }

    @Override
    public MMU createMMU() {
        return new EnginolaMMU();
    }
}


//Abstract factory
enum Architecture {
    ENGINOLA, EMBER
}

abstract class AbstractFactory {
    private static final EmberToolkit EMBER_TOOLKIT = new EmberToolkit();
    private static final EnginolaToolkit ENGINOLA_TOOLKIT = new EnginolaToolkit();

    static AbstractFactory getFactory(Architecture architecture) {
        AbstractFactory factory = null;
        switch (architecture) {
            case ENGINOLA:
                factory = ENGINOLA_TOOLKIT;
                break;
            case EMBER:
                factory = EMBER_TOOLKIT;
                break;
        }
        return factory;
    }

    public abstract CPU createCPU();

    public abstract MMU createMMU();
}

public class BasicAbstractFactory {
    public static void main(String[] args) {
        AbstractFactory emberFactory = AbstractFactory.getFactory(Architecture.EMBER);
        CPU cpu = emberFactory.createCPU();
        System.out.println(cpu);

        AbstractFactory enginolaFactory = AbstractFactory.getFactory(Architecture.ENGINOLA);
        MMU mmu = enginolaFactory.createMMU();
        System.out.println(mmu);
    }
}