抽象工廠模式

抽象工廠模式

通過一個接口創建一系列相關的對象，而不需要指定具體的類（由工廠完成）

注意，工廠模式是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);
    }
}