【设计模式】工厂设计模式（抽象工厂模式）

最新推荐文章于 2024-05-20 23:45:16 发布

superLango

最新推荐文章于 2024-05-20 23:45:16 发布

阅读量25

点赞数

分类专栏：设计模式文章标签：设计模式抽象工厂模式 java

本文链接：https://blog.csdn.net/qq_62200539/article/details/130796517

版权

设计模式专栏收录该内容

11 篇文章 0 订阅

订阅专栏

抽象工厂模式

完整需求请查看：
简单工厂模式
 工厂方法模式

基本介绍

抽象工厂模式：定义了一个 interface 用于创建相关或有依赖关系的对象簇，而无需指明具体的类
抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合
从设计层面看，抽象工厂模式就是对简单工厂模式的改进（或者称为进一步的抽象）
将工厂抽象成两层，AbsFactory（抽象工厂）和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

在这里插入图片描述

代码示例：

pizza: 同上

order:

package com.lango.factory.absfactory.pizzastore.order;

import com.lango.factory.absfactory.pizzastore.pizza.Pizza;

/**
 * @author Lango
 * @version 1.0
 */
// 抽象工厂模式的抽象层（接口）
public interface AbsFactory {
    // 让下面的工厂子类具体实现
    public Pizza createPizza(String orderType);
}

package com.lango.factory.absfactory.pizzastore.order;

import com.lango.factory.absfactory.pizzastore.pizza.BJCheesePizza;
import com.lango.factory.absfactory.pizzastore.pizza.BJPepperPizza;
import com.lango.factory.absfactory.pizzastore.pizza.Pizza;

/**
 * @author Lango
 * @version 1.0
 */
public class BJFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("使用的是抽象工厂模式");
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}

package com.lango.factory.absfactory.pizzastore.order;

import com.lango.factory.absfactory.pizzastore.pizza.LDCheesePizza;
import com.lango.factory.absfactory.pizzastore.pizza.LDPepperPizza;
import com.lango.factory.absfactory.pizzastore.pizza.Pizza;

/**
 * @author Lango
 * @version 1.0
 */
public class LDFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("使用的是抽象工厂模式");
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new LDCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

package com.lango.factory.absfactory.pizzastore.order;


import com.lango.factory.absfactory.pizzastore.pizza.Pizza;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author Lango
 * @version 1.0
 */
public class OrderPizza {

    AbsFactory factory;

    public OrderPizza(AbsFactory factory) {
        setFactory(factory);
    }

    private void setFactory(AbsFactory factory) {
        Pizza pizza = null;
        String orderType = ""; // 用户输入
        this.factory = factory;

        do {
            orderType = getType();
            // factory 可能是北京的工厂子类，也可能是伦敦的工厂子类
            pizza = factory.createPizza(orderType);
            if (pizza != null) {
                // 输出 pizza 制作过程
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                return;
            }
        } while (true);
    }

    // 写一个方法，可以获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println(" input pizza type: ");
            return bufferedReader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

test:

package com.lango.factory.absfactory.pizzastore.order;

/**
 * @author Lango
 * @version 1.0
 */
public class PizzaStore {
    public static void main(String[] args) {
//        new OrderPizza(new BJFactory());
        new OrderPizza(new LDFactory());
    }
}

工厂模式在 JDK-Calendar 应用的源码分析

JDK 中的 Calendar 类中，就使用了简单工厂模式

public static Calendar getInstance()
    {
        return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
    }

 private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale)
    {
        CalendarProvider provider =
            LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                 .getCalendarProvider();
        if (provider != null) {
            try {
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
                // fall back to the default instantiation
            }
        }

        Calendar cal = null;

        if (aLocale.hasExtensions()) {
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }
        if (cal == null) {
            // If no known calendar type is explicitly specified,
            // perform the traditional way to create a Calendar:
            // create a BuddhistCalendar for th_TH locale,
            // a JapaneseImperialCalendar for ja_JP_JP locale, or
            // a GregorianCalendar for any other locales.
            // NOTE: The language, country and variant strings are interned.
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                       && aLocale.getCountry() == "JP") {
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
    }