提供一个用来创建一系列有依赖关系的对象，并且不用指定具体的类。

解释

现实世界

创建一个王国需要一系列共同主题的对象。比如创建一个精灵王国需要一个精灵国王、精灵城堡和精灵军队，创建兽人王国需要一个兽人国王、兽人城堡和兽人军队。王国之间的对象之间存在依赖关系。

维基百科

抽象工厂模式提供了一种封装一组具有共同主题的独立工厂的方法，而无需指定他们具体的类。

总结

简单来说抽象工厂就是将独立的但是又互相有依赖关系的工厂组合在一起而不指定具体类的工厂。

示例

基础互相依赖接口

//国王类
public interface King {

    String getDescription();

}

//城堡类
public interface Castle {

    String getDescription();

}

//军队
public interface Army {

    String getDescription();

}

精灵

//精灵国王
public class ElfKing implements King {
    String description = "The elven king";


    @Override
    public String getDescription() {
        return description;
    }
}

//精灵城堡
public class ElfCastle implements Castle {

    String description = "The elven castle";

    @Override
    public String getDescription() {
        return description;
    }
}

//精灵军队
public class ElfArmy implements Army {
    String description = "The elven army";


    @Override
    public String getDescription() {
        return description;
    }
}

兽人

//兽人国王
public class OrishKing implements King {
    String description = "The Orcish king";

    @Override
    public String getDescription() {
        return description;
    }
}

//兽人城堡
public class OrishCastle implements Castle {
    String description = "The Orcish castle";
    
    @Override
    public String getDescription() {
        return description;
    }
}

//兽人军队
public class OrcishArmy implements Army {
    String description = "The Orcish army";
    @Override
    public String getDescription() {
        return description;
    }
}

工厂

public interface KingdomFactory {

    Castle createCastle();

    Army createArmy();

    King createKing();

}

精灵工厂

public  class ElfKingdomFactory implements KingdomFactory{

    @Override
    public Castle createCastle() {
        return new ElfCastle();
    }

    @Override
    public Army createArmy() {
        return new ElfArmy();
    }

    @Override
    public King createKing() {
        return new ElfKing();
    }
}

兽人工厂

public class OrcKingdomFactory implements KingdomFactory{

    @Override
    public Castle createCastle() {
        return new OrishCastle();
    }

    @Override
    public Army createArmy() {
        return new OrcishArmy();
    }

    @Override
    public King createKing() {
        return new OrishKing();
    }
}

抽象工厂

public static class FactoryMaker {

        enum KingdomType {
            /**
             * 精灵
             */
            ELF,
            /**
             * 兽人
             */
            ORC;
        }

        public static KingdomFactory makeKingdomFactory(KingdomType kingdomType) {

            switch (kingdomType) {
                case ORC:
                    return new OrcKingdomFactory();
                default:
                    return new ElfKingdomFactory();
            }

        }

}

使用

public class App {

    private static Kingdom kingdom = new Kingdom();

    public static void main(String[] args) {

        createKingdom(Kingdom.FactoryMaker.KingdomType.ELF);

        System.out.println(kingdom);
    }

    public static void createKingdom(Kingdom.FactoryMaker.KingdomType kingdomType){
        KingdomFactory kingdomFactory = Kingdom.FactoryMaker.makeKingdomFactory(kingdomType);
        kingdom.setArmy(kingdomFactory.createArmy());
        kingdom.setCastle(kingdomFactory.createCastle());
        kingdom.setKing(kingdomFactory.createKing());
    }

}

使用场景

• 系统的相关产品对象需要一起使用，需要强制约束
• 需要在运行时构造特定的依赖项
• 需要在运行时才决定调用哪个对象
• 需要提供一个或者多个在运行时才明确的参数，才能解决依赖关系
• 当需要产品之间的一致性
• 在添加新的产品或者产品系列时不希望更改现有代码

缺点

增加了代码的复杂性，工厂模式的引入带来了许多新的接口和类 。

参考

• Java Design Patterns