工厂模式--抽象工厂模式

抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

使用场景：当需要创建产品家族和想让制造的相关产品集合起来时，可以使用。

优点：把客户从所使用的实际具体产品中解耦。

工厂方法模式和抽象工厂模式的区别：

    工厂方法使用继承（把对象的创建委托给子类，子类实现工厂方法来创建对象）。

    抽象工厂使用对象组合（对象的创建被实现在工厂接口所暴露出来的方法中）。

代码：

原料家族：

interface X {
}

class X1 implements X {
    public X1() {
        System.out.println("原料X1---创建");
    }
}
class X2 implements X {
    public X2() {
        System.out.println("原料X2---创建");
    }
}

interface Y {
}

class Y1 implements Y {
    public Y1() {
        System.out.println("原料Y1---创建");
    }
}
class Y2 implements Y {
    public Y2() {
        System.out.println("原料Y2---创建");
    }
}

interface Z {
}

class Z1 implements Z {
    public Z1() {
        System.out.println("原料Z1---创建");
    }
}
class Z2 implements Z {
    public Z2() {
        System.out.println("原料Z2---创建");
    }
}

原料工厂（不同工厂供应的原料不一样）

public interface MaterialFactory {
    public X createX();
    public Y createY();
    public Z createZ();
}

class MaterialFactoryA implements MaterialFactory {

    @Override
    public X createX() {
        return new X1();
    }

    @Override
    public Y createY() {
        return new Y1();
    }

    @Override
    public Z createZ() {
        return new Z1();
    }
}

class MaterialFactoryB implements MaterialFactory {

    @Override
    public X createX() {
        return new X2();
    }

    @Override
    public Y createY() {
        return new Y2();
    }

    @Override
    public Z createZ() {
        return new Z2();
    }
}

产品（不同工厂里生产的同种产品本质不同，因为原料不同。这里用到了产品和工厂的组合从而可以合成了不同的对象）

public abstract class Product {
    X x;
    Y y;
    Z z;
    String name;

    abstract void prepare();

    public void work1() {
        System.out.println(name + "---w1");
    }

    public void work2() {
        System.out.println(name + "---w2");
    }

    public void work3() {
        System.out.println(name + "---w3");
    }
}

class Product1 extends Product {
    private MaterialFactory materialFactory;

    public Product1(MaterialFactory materialFactory) {
        this.materialFactory = materialFactory;
    }

    @Override
    void prepare() {
        System.out.println("准备Product1的原料");
        x = materialFactory.createX();
        y = materialFactory.createY();
        z = materialFactory.createZ();
        name = materialFactory.getClass().getName();
    }
}

class Product2 extends Product {
    private MaterialFactory materialFactory;

    public Product2(MaterialFactory materialFactory) {
        this.materialFactory = materialFactory;
    }

    @Override
    void prepare() {
        System.out.println("准备Product2的原料");
        x = materialFactory.createX();
        y = materialFactory.createY();
        z = materialFactory.createZ();
        name = materialFactory.getClass().getName();
    }
}

class Product3 extends Product {
    private MaterialFactory materialFactory;

    public Product3(MaterialFactory materialFactory) {
        this.materialFactory = materialFactory;
    }

    @Override
    void prepare() {
        System.out.println("准备Product3的原料");
        x = materialFactory.createX();
        y = materialFactory.createY();
        z = materialFactory.createZ();
        name = materialFactory.getClass().getName();
    }
}

产品制作商店（不同的制作商店对应不同的原料工厂，不同的原料工厂生产相同产品最终本质不同，这里是实际组合工厂和产品的地方）

public abstract class Store {
    protected abstract Product createP(int type);

    public Product makeP(int type) {
        Product p = createP(type);
        p.prepare();
        p.work1();
        p.work2();
        p.work3();
        return p;
    }
}

class StoreA extends Store {

    @Override
    protected Product createP(int type) {
        Product p = null;
        MaterialFactory factory = new MaterialFactoryA();
        if (type == 1) {
            p = new Product1(factory);
        } else if (type == 2) {
            p = new Product2(factory);
        } else if (type == 3) {
            p = new Product3(factory);
        }

        return p;
    }
}

class StoreB extends Store {

    @Override
    protected Product createP(int type) {
        Product p = null;
        MaterialFactory factory = new MaterialFactoryB();
        if (type == 1) {
            p = new Product1(factory);
        } else if (type == 2) {
            p = new Product2(factory);
        } else if (type == 3) {
            p = new Product3(factory);
        }

        return p;
    }
}

消费产品：

public class AbstractFactoryTest {
    public static void main(String[] args) {
        Store sa = new StoreA();
        Store sb = new StoreB();

        Product p_a_1 = sa.makeP(1);
        Product p_a_2 = sa.makeP(2);
        Product p_a_3 = sa.makeP(3);

        Product p_b_1 = sb.makeP(1);
        Product p_b_2 = sb.makeP(2);
        Product p_b_3 = sb.makeP(3);

    }
}