哇塞！抽象工厂模式还能这样玩

设计模式之抽象工厂模式

这个类图比较简单，也很直观。一个接口，多个抽象类，然后多个实现类。每个人种都是抽象类，性别是在各个实现类中实现的。HumanFactory定义了三个方法，分别创建三个不同肤色的人类。

人种有三个抽象类，负责人种的抽象属性定义：肤色和语言，

人种接口

public interface Human {
    void getTalk();
    void getColor();
    void getSex();
}

人种有三个抽象类，负责人种的抽象属性定义
黑色人种

public abstract class AbstractBlackHuman implements Human{
    @Override
    public void getTalk() {
        System.out.println("黑人说话听不懂");
    }
    @Override
    public void getColor() {
        System.out.println("我的皮肤是黑色的");
    }
}

白色人种

public abstract class AbstractWhiteHuman implements Human{
    @Override
    public void getTalk() {
        System.out.println("我是一个白人");
    }
    @Override
    public void getColor() {
        System.out.println("我的皮肤是白色的");
    }
}

黄色人种

public abstract class AbstractYellowHuman implements Human{
    @Override
    public void getTalk() {
        System.out.println("黄种人说话最好听");
    }
    @Override
    public void getColor() {
        System.out.println("我的皮肤是黄色的");
    }
}

每个抽象类都有两个实现，分别实现公共的细节最具体的事物。
定义一个黑人女性

public class FamaleBlackHuman extends AbstractYellowHuman {
    @Override
    public void getSex() {
        System.out.println("黑人女性");
    }
}

黑人男性人种

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

八卦炉的定义，分别创建三个不同肤色的人

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

八卦炉的细分，生产女性的八卦炉

public class FamaleFactory implements HummanFactory {
    @Override
    public Human createBlackHuman() {
        return new FamaleBlackHuman();
    }
    @Override
    public Human createYellowHuman() {
        return new FamaleYellowHuman();
    }
    @Override
    public Human createWhiteHuman() {
        return null;
    }
}

生产男性的八卦炉

public class MaleFactory implements HummanFactory {
    @Override
    public Human createBlackHuman() { return new MaleBlackHuman(); }
    @Override
    public Human createYellowHuman() {
        return new MaleBlackHuman();
    }
    @Override
    public Human createWhiteHuman() {
        return null;
    }
}

女娲重造人类

public class NvWa {
    public static void main(String[] args){
        //第一条生产线，男性生产线
        HummanFactory balckMale = new MaleFactory();
        //创建人类
        Human human = balckMale.createBlackHuman();
        human.getSex();
    }
}

总结

• 每个工厂有很多车间，每个车间又分多条生产线，分别生成不同的产品，我们可以吧八卦炉比喻为车间，把八卦炉的工艺叫做生产线。如此看来就是女性生产车间生产不同肤色的女性，男性生产车间生产不同肤色的男性。

抽象工厂的定义

• 为创建一组相关或相互依赖的对象提供一个接口，而且无须指定他们的具体类。

• 抽象工厂是工厂模式的升级版本，在有多个业务品种，业务分类时，通过抽象工厂模式产生需要的对象是一种非常号的解决方式。

• 两个抽象类产品类可以有关系，例如共同继承和实现一个抽象类接口。

定义抽象产品类

public abstract  class AbstractProductA {
    /**
     * 共享方法
     */
    public void shareMethod(){}
    /**
     * 每个产品相同的方法， 不同的实现
     */
    public abstract void doSomeThimg();
}

产品类A1的实现类

public class ProductA1 extends AbstractProductA{
    @Override
    public void doSomeThimg() {
        System.out.println("产品A1的实现");
    }
}

产品类A2的实现

public class ProductA2 extends AbstractProductA{
    @Override
    public void doSomeThimg() {
        System.out.println("产品A2的实现");
    }
}

抽象工厂类AbstractCreator的职责是定义每个工厂要实现的功能。

public abstract class AbstractCreator {
    //创建A产品类
    public abstract AbstractProductA createProductA();
    //创建B产品类
    public abstract AbstractProductB createProductB();
    //todo 有N个产品类，在抽象工厂类中就应该有N个创建方法
}

创建一个产品是由实现类来完成的，Creator1和Creator2
产品等级1的实现

public class Creator1 extends AbstractCreator {
    //创建产品等级为1 的A类产品
    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }
    //创建产品等级为1 的B类产品
    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
    //todo 有M个产品等级就应该有M个实现工厂类，在每个实现工厂中，实现不同产品类的生成任务。
}

产品等级2的实现

public class Creator2 extends AbstractCreator {
    //创建产品等级为2的A类产品
    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }
    //创建产品等级为2的B类产品
    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}

场景类

public class Client {
    //场景类
    public static void mian(String[] args){
        AbstractCreator abstractCreator = new Creator1();
        AbstractCreator abstractCreator12 = new Creator2();
        //产生A1对象
        abstractCreator.createProductA();
        //产生A2对象
        abstractCreator12.createProductA();
        //产生B1对象
        abstractCreator.createProductB();
        //产生B2对象
        abstractCreator12.createProductB();
    }
}

在产品类上，没有一个方法与实现类有关系，对于一个产品来说，我们只要知道它的工厂方法就可以直接产生一个产品对象，无须关心它的实现类。

抽象工厂的优点：

• 封装性，每个产品的实现类不是高层模块需要关心的， 它要关心的是接口，抽象类，它不关心对象是如何创建出来的，由谁负责的，工厂类，只要知道工厂类是谁，就能创建出一个需要的对象。
• 产品族内的约束为非公开状态，举个例子，加入女娲有自己的想法，她不想女盛男衰，它想每生产一个女性，就生产1.2倍的男生，但是对于实现高层是不需要的，也不关心，它只需要知道我调用的类，接口，我要创建一个人。

抽象工厂的缺点：

• 抽象工厂最大的缺点就是扩展困难，加入我们要加入一个产品C，也就是说原先的产品家族由2个变成3个，AbstractCreator要增加一个createProductC(),然后两个实现类都要改变。打个比方，抽象类和接口是一个契约，改变契约，所有与契约有关系的代码都要改掉。

抽象工厂的使用场景：

• 一个对象族或是一组没有任何关系的对象都有相同的约束，则可以使用工厂模式。
• 举例说明：一个文本编辑器和一个图片编辑器，在不同操作系统下面他们的代码都不同，但是他们的界面和功能是相同的，于实我们可以用抽象工厂模式，产生不同操作系统下面的文本编辑器和图片编辑器。
  抽象工厂的注意事项；

最佳实践：

• 一个应用，需要应用在不同操作系统下面（Windows，Linux,Andorid)上运行，他们都有相同的约束，但是他们要实现 的效果都是一样的（软件功能，应用逻辑，Ui），所以这个时候我们可以用抽象工厂模式创建不同操作系统下面的应用，由不同的产品类去处理与操作系统交互的信息。