抽象工厂模式

适用场景

别的工厂都只是生产一种产品，而抽象工厂模式用于生产一个产品族。什么是产品族呢？就是不同种类产品的组合。比如说，啤酒、饮料、花生米构成了一个产品族，而单单的花生米，有洽洽香瓜子，有三只松鼠的，有良品铺子的之类的只属于一类产品。
而抽象工厂模式就是要解决生产不同产品类组合的问题。

类图

抽象工厂模式.png

代码实现

调用

package com.company;

public class Main {

    public static void main(String[] args) {
    // write your code here
        AbstractFactory factoryOne = new FactoryC();
        ProductA productA0 = factoryOne.produceProductA();
        productA0.printProductInformation();
        ProductB productB0 = factoryOne.produceProductB();
        productB0.printGoodInformation();

        AbstractFactory factoryTwo = new FactoryD();
        ProductA productA1 = factoryTwo.produceProductA();
        productA1.printProductInformation();
        ProductB productB1 = factoryTwo.produceProductB();
        productB1.printGoodInformation();
    }
}

输出

这是A0产品
这是B0产品
这是A1产品
这是B1产品

Process finished with exit code 0

A产品接口

package com.company;

public interface ProductA {
    void printProductInformation();
}

A0产品

package com.company;

public class ProductA0 implements ProductA {
    @Override
    public void printProductInformation() {
        System.out.println("这是A0产品");
    }
}

A1产品

package com.company;

public class ProductA1 implements ProductA {
    @Override
    public void printProductInformation() {
        System.out.println("这是A1产品");
    }
}

B产品接口

package com.company;

public interface ProductB {
    void printGoodInformation();
}

B0产品

package com.company;

public class ProductB0 implements ProductB {
    @Override
    public void printGoodInformation() {
        System.out.println("这是B0产品");
    }
}

B1产品

package com.company;

public class ProductB1 implements ProductB {
    @Override
    public void printGoodInformation() {
        System.out.println("这是B1产品");
    }
}

抽象工厂接口

package com.company;

public interface AbstractFactory {
    ProductA produceProductA();
    ProductB produceProductB();
}

C工厂

package com.company;

public class FactoryC implements AbstractFactory {
    @Override
    public ProductA produceProductA() {
        return new ProductA0();
    }

    @Override
    public ProductB produceProductB() {
        return new ProductB0();
    }
}

D工厂

package com.company;

public class FactoryD implements AbstractFactory {
    @Override
    public ProductA produceProductA() {
        return new ProductA1();
    }

    @Override
    public ProductB produceProductB() {
        return new ProductB1();
    }
}

返回