抽象工厂模式

在前面我们讲述了工厂方法模式，以女娲造人为例，我们有了黄 黑 白 三个肤色的人，但是正常我们又分为男人和女人。那么怎么改造能让我们能分别制造出黄黑白的男人和女人呢。

接下来是具体代码案例：

• 人类接口

/**
 * 人类接口
 */
public interface Human {
    void getColor();

    void talk();

    void getSex();
}

• 然后人类有三个抽象类，分别代表了黑 黄 白种人

public abstract class AbstractBlackHuman implements Human {
    @Override
    public void getColor() {
        System.out.println("黑色皮肤");
    }

    @Override
    public void talk() {
        System.out.println("黑色人会说话");
    }
}


public abstract class AbstractWhiteHuman implements Human {
    @Override
    public void getColor() {
        System.out.println("白色皮肤");
    }

    @Override
    public void talk() {
        System.out.println("白色人会说话");
    }
}

public abstract class AbstractYellowHuman implements Human {
    @Override
    public void getColor() {
        System.out.println("黄色皮肤");
    }

    @Override
    public void talk() {
        System.out.println("黄色人会说话");
    }
}

• 然后每个抽象类都有两个实现类，分别对应的男人和女人

public class FemaleBlackHuman extends AbstractBlackHuman {
    @Override
    public void getSex() {
        System.out.println("黑色女人");
    }
}

public class MaleBlackHuman extends AbstractBlackHuman {
    @Override
    public void getSex() {
        System.out.println("男性黑人");
    }
}

public class FemaleWhiteHuman extends AbstractWhiteHuman {
    @Override
    public void getSex() {
        System.out.println("女性白人");
    }
}
public class MaleWhiteHuman extends AbstractWhiteHuman {
    @Override
    public void getSex() {
        System.out.println("男性白人");
    }
}

public  class FemaleYellowHuman extends AbstractYellowHuman{

    @Override
    public void getSex() {
        System.out.println("黄色女性");
    }
}

public  class MaleYellowHuman extends AbstractYellowHuman {

    @Override
    public void getSex() {
        System.out.println("黄色男性");
    }

}

• 接下来就是通过工厂来造人，我们需要两个工厂来分别创建男性和女性

public interface HumanFactory {
    Human createYellowHuman();
    Human createWhiteHuman();
    Human createBlackHuman();
}

public class FemaleFactory implements HumanFactory {
    @Override
    public Human createYellowHuman() {
        return new FemaleYellowHuman();
    }

    @Override
    public Human createWhiteHuman() {
        return new FemaleWhiteHuman();
    }

    @Override`在这里插入代码片`
    public Human createBlackHuman() {
        return new FemaleBlackHuman();
    }
}

public class MaleFactory implements HumanFactory {
    @Override
    public Human createYellowHuman() {
        return new MaleYellowHuman();
    }

    @Override
    public Human createWhiteHuman() {
        return new MaleWhiteHuman();
    }

    @Override
    public Human createBlackHuman() {
        return new MaleBlackHuman();
    }
}

• 最后就是通过工厂开始造人了：

 public static void main(String[] args) {
        MaleFactory factory = new MaleFactory();
        Human blackHuman = factory.createBlackHuman();
        blackHuman.talk();
        blackHuman.getColor();
        blackHuman.getSex();
        Human whiteHuman = factory.createWhiteHuman();
        whiteHuman.talk();
        whiteHuman.getColor();
        whiteHuman.getSex();
        Human yellowHuman = factory.createYellowHuman();
        yellowHuman.talk();
        yellowHuman.getColor();
        yellowHuman.getSex();

        FemaleFactory femalFactory = new FemaleFactory();
        Human blackHuman1 = femalFactory.createBlackHuman();
        blackHuman1.talk();
        blackHuman1.getColor();
        blackHuman1.getSex();
        Human whiteHuman1 = femalFactory.createWhiteHuman();
        whiteHuman1.talk();
        whiteHuman1.getColor();
        whiteHuman1.getSex();
        Human yellowHuman1 = femalFactory.createYellowHuman();
        yellowHuman1.talk();
        yellowHuman1.getColor();
        yellowHuman1.getSex();
    }

• 抽象工厂模式的定义
  其定义如下：为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们 的具体类。
  抽象工厂模式的通用类图如图
  
  抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象 工厂模式产生需要的对象是一种非常好的解决方式。我们来看看抽象工厂的通用源代码，首 先有两个互相影响的产品线（也叫做产品族），例如制造汽车的左侧门和右侧门，这两个应 该是数量相等的——两个对象之间的约束，每个型号的车门都是不一样的，这是产品等级结 构约束的，我们先看看两个产品族的类图
  
  其源代码如下：

/**
 * 抽象产品类
 */
public abstract class AbstractProductA {
    public void shareMethod(){

    }

    public abstract void doSomething();
}

public abstract class AbstractProductB {
    public void shareMethon() {
        System.out.println("B产品公共方法");
    }

    public abstract void doSomething();

}

抽象产品实现类

public  class ProductA1 extends AbstractProductA{

    @Override
    public void doSomething() {
        System.out.println("产品A1实现方法");
    }
}
public class ProductA2 extends AbstractProductA {

    @Override
    public void doSomething() {
        System.out.println("产品A2实现方法");
    }
}

public class ProductB1 extends AbstractProductB {
    @Override
    public void doSomething() {
        System.out.println("B1产品实现方法");
    }
}
public class ProductB2 extends AbstractProductB {
    @Override
    public void doSomething() {
        System.out.println("B2产品实现方法");
    }
}

抽象工厂类

public abstract class AbstractCreator {

    abstract AbstractProductA createProductA();

    abstract AbstractProductB createProductB();

}

产品等级实现类

/**
 * 只生产等级为1 的产品
 */
public class Creator1 extends AbstractCreator {
    @Override
    AbstractProductA createProductA() {
        return new ProductA1();
    }

    @Override
    AbstractProductB createProductB() {
        return new ProductB1();
    }
}

/**
 * 只生产等级为2 的产品
 */
public class Creator2 extends AbstractCreator {
    @Override
    AbstractProductA createProductA() {
        return new ProductA2();
    }

    @Override
    AbstractProductB createProductB() {
        return new ProductB2();
    }
}

调用方式

public class Test {
    public static void main(String[] args) {
        Creator1 creator1 = new Creator1();
        creator1.createProductA();
        creator1.createProductB();

        Creator2 creator2 = new Creator2();
        creator2.createProductA();
        creator2.createProductB();
    }
}

• 抽象工厂模式的应用
  优点：封装性、产品族内约束为非公开装备
  缺点：扩展困难，违反了开闭原则。如果增加产品，从产品到工厂都需要增加。