[设计模式]抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

---

意图

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

---

实现

我们这边实现一个功能如下

有几本书，并且还有几个等级，我需要获得书本和等级

使用抽象工厂模式就是创建两种工厂，书本工厂和等级工厂，在创建一个抽象工厂把全部工厂都放入，需要书本和等级的时候，只需要调用抽象工厂就可以获取到了。

• 创建接口

    public interface Book{
        void BookName();
    }

    public interface Grade{
        void grade();
    }

• 创建实体类

    public static class MathBook implements Book {

        @Override
        public void BookName() {
            System.out.println(this.getClass().getName());
        }
    }

    public static class EnglishBook implements Book {

        @Override
        public void BookName() {
            System.out.println(this.getClass().getName());
        }
    }

    public static class Primary implements Grade {

        @Override
        public void grade() {
            System.out.println(this.getClass().getName());
        }
    }

    public static class Intermediate implements Grade {

        @Override
        public void grade() {
            System.out.println(this.getClass().getName());
        }
    }

    public static class Senior implements Grade {

        @Override
        public void grade() {
            System.out.println(this.getClass().getName());
        }
    }

• 创建抽象工厂

    public static abstract class AbstractFactory{
        abstract Book getBook(String name);
        abstract Grade getGrade(String level);
    }

• 创建工厂

    public static class BookFactory extends AbstractFactory{

        @Override
        Book getBook(String name) {
            switch (name){
                case "Math":
                    return new MathBook();
                case "English":
                    return new EnglishBook();
            }
            return null;
        }

        @Override
        Grade getGrade(String level) {
            return null;
        }
    }


    public static class GradeFactory extends AbstractFactory{

        @Override
        Book getBook(String name) {
            return null;
        }

        @Override
        Grade getGrade(String level) {
            switch (level){
                case "Primary":
                    return new Primary();
                case "Intermediate":
                    return new Intermediate();
                case "Senior":
                    return new Senior();
            }
            return null;
        }
    }

• 创建抽象工厂实体类

    public static class FactoryProducer{
        public static AbstractFactory getFactory(String factory){
            switch (factory){
                case "Book":
                    return new BookFactory();
                case "Grade":
                    return new GradeFactory();
            }
            return null;
        }
    }

• 使用

    public static void main(String... args) {
        AbstractFactory abstractFactory;
        Book book;
        Grade grade;

        abstractFactory = FactoryProducer.getFactory("Book");
        book = abstractFactory.getBook("Math");
        book.BookName();

        book = abstractFactory.getBook("Math");
        book.BookName();

        abstractFactory = FactoryProducer.getFactory("Grade");
        grade = abstractFactory.getGrade("Primary");
        grade.grade();

        grade = abstractFactory.getGrade("Intermediate");
        grade.grade();

        grade = abstractFactory.getGrade("Senior");
        grade.grade();
    }

• 结果

I/System.out: com.gjn.opencv.Model$MathBook
I/System.out: com.gjn.opencv.Model$EnglishBook
I/System.out: com.gjn.opencv.Model$Primary
I/System.out: com.gjn.opencv.Model$Intermediate
I/System.out: com.gjn.opencv.Model$Senior

我们可以看到，抽象工厂模式就是将多个工厂模式的整合。

我们可以看出，工厂模式和抽象工厂模式都是为了解耦，使用工厂模式类型的时候，看需求选择模式！

---

资料

菜鸟教程