在JAVA语言程序设计中，抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。希望对大家学习JAVA语言程序设计有所帮助。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

意图

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

实现

创建接口

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

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

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

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注编程语言JAVA频道！