Geeks_Z の Blog
Geeks_Z
2023-01-15
目录

工厂模式

工厂模式

6.1 简单工厂模式

6.1.1 看一个具体的需求

看一个披萨项目，要便于披萨种类的扩展，要便于维护

1、披萨的种类很多，比如GreekPizz，CheesePiz 等

2、披萨的制作有 prepare准备，bake烤，cut 切 box 包装

3、完成披萨店订购功能

6.1.2 使用传统方式来完成

1、思路分析(类图)

编写 OrderPizza.java 去订购需要的各种 pizza

2、看老师代码演示

/* public OrderPizza() {
     Pizza pizza = null;
     String orderType; //披萨订购的类型
     do{
         orderType = gettype();
         if (orderType.equals("greek")) {
             pizza = new GreekPizza();
             pizza.setName(" 希腊披萨 ");
         } else if (orderType.equals("cheese")) {
             pizza = new CheesePizza();
             pizza.setName(" 奶酪披萨 ");
         } else if(orderType.equals("pepper")) {
             pizza = new PepperPizza();
             pizza.setName("胡椒披萨");
         } else {
             break;
         }
         // 输出pizza制作过程
         pizza.prepare();
         pizza.bake();
         pizza.cut();
         pizza.box();
     }while (true);
 }*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

6.1.3 传统方式的优缺点

  1. 优点是比较好理解，简单易操作
  2. 缺点是违反了设计模式的ocp原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码.
  3. 比如我们这时要新增加一个Pizza的种类(Pepper披萨)，我们需要做如下修改.

如果我们增加一个Pizza类，只要是订购Pizza的代码都需要修改

  1. 改进思路分析

    分析:修改代码可以接受,但是如果我们在其它的地方也有创建Pizza的代码，就意味着，也需要修改,而创建Pizza的代码，往往有多处。. 思路:把创建Pizza 对象封装到一个类中,这样我们有新的Pizza种类时，只需要修改该类就可,其它有创建到Pizza对象的代码就不需要修改了.->简单工厂模式

6.1.4 简单工厂模式基本介绍

  1. 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一-个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式.
  2. 简单工厂模式:定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)
  3. 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式.

6.1.5 使用简单工厂模式

  1. 简单工厂模式设计方案，定义一个实例化 Pizza对象的类，封装创建对象的代码

  2. 看代码示例：

    package com.atguigu.factory.simplefactory.pizzastore.order;

import com.atguigu.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.atguigu.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.atguigu.factory.simplefactory.pizzastore.pizza.PepperPizza;
import com.atguigu.factory.simplefactory.pizzastore.pizza.Pizza;

/**
 * 简单工厂
 *
 * @author gcq
 * @Create 2020-09-30
 */
public class SimpleFactory {

    /**
     * 根据orderType 返回对应的Pizza 对象
     * @param orderType
     * @return
     */
    public static Pizza createPizza(String orderType) {

        Pizza pizza = null;
        System.out.println("使用简单工厂模式");
        if (orderType.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName(" 希腊披萨 ");
        } else if (orderType.equals("cheese")) {
            pizza = new CheesePizza();
            pizza.setName(" 奶酪披萨 ");
        } else if(orderType.equals("pepper")) {
            pizza = new PepperPizza();
            pizza.setName("胡椒披萨");
        }
        return pizza;
    }
    // 简单工厂模式也叫静态工厂模式

}
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
package com.atguigu.factory.simplefactory.pizzastore.order;

import com.atguigu.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.atguigu.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.atguigu.factory.simplefactory.pizzastore.pizza.PepperPizza;
import com.atguigu.factory.simplefactory.pizzastore.pizza.Pizza;

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

/**
 * @author gcq
 * @Create 2020-09-30
 */
public class OrderPizza {

   /* public OrderPizza() {
        Pizza pizza = null;
        String orderType; //披萨订购的类型
        do{
            orderType = gettype();
            if (orderType.equals("greek")) {
                pizza = new GreekPizza();
                pizza.setName(" 希腊披萨 ");
            } else if (orderType.equals("cheese")) {
                pizza = new CheesePizza();
                pizza.setName(" 奶酪披萨 ");
            } else if(orderType.equals("pepper")) {
                pizza = new PepperPizza();
                pizza.setName("胡椒披萨");
            } else {
                break;
            }
            // 输出pizza制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while (true);
    }*/

    //定义一个简单工厂对象
    SimpleFactory simpleFactory;

    Pizza pizza = null;

    //构造器
    public OrderPizza(SimpleFactory simpleFactory) {
        setFactory(simpleFactory);
    }
    public void setFactory(SimpleFactory simpleFactory) {
        // 用户输入的
        String orderType = "";

        // 设置简单工厂对象
        this.simpleFactory = simpleFactory;
        do{
            orderType = gettype();
            pizza = this.simpleFactory.createPizza(orderType);

            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println(" 订购披萨失败");
                break;
            }
        }while(true);
    }

    //写一个方法 可以获取客户希望订购的披萨类
    private String gettype() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = strin.readLine();
            return str;
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

6.2 工厂方法模式

6.2.1 看一个新的需求

​ 披萨项目新的需求:客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪pizza、北京的胡椒pizza或者是伦敦的奶酪pizza、伦敦的胡椒pizza。

6.2.1 思路1

​ 使用简单工厂模式，创建不同的简单工厂类，比如BJPizzaSimpleFactory、LDPizzaSimpleFactory等等从当前这个案例来说，也是可以的，但是考虑到项目的规模，以及软件的可维护性、可扩展性并不是特别好

6.2.2 思路2

​ 使用工厂方法模式

6.2.4 工厂方法模式介绍

1、工厂方法模式设计方案:将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现。

2、工厂方法模式**:定义了一个创建对象的抽象方法**，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

6.2.5 工厂方法模式应用案例

1、披萨项目新的需求:客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪pizza、北京的胡椒pizza或者是伦敦的奶酪pizza、伦敦的胡椒pizza

2、思路分析

3、代码实现

package com.atguigu.factory.factorymethod.pizzastore.order;


import com.atguigu.factory.factorymethod.pizzastore.pizza.Pizza;

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

/**
 * @author gcq
 * @Create 2020-09-30
 */
public abstract class OrderPizza {

    // 定义一个抽象方法 createPizza 让各个工厂子类自己实现
    abstract Pizza createPizza(String orderType);

    public OrderPizza() {
        Pizza pizza = null;
        String orderType; //披萨订购的类型
        do{
            orderType = gettype();
            // 抽象方法 由工厂子类完成
          pizza = createPizza(orderType);
            // 输出pizza制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while (true);
    }



    //写一个方法 可以获取客户希望订购的披萨类
    private String gettype() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = strin.readLine();
            return str;
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

子类实现

package com.atguigu.factory.factorymethod.pizzastore.order;

import com.atguigu.factory.factorymethod.pizzastore.pizza.BJCheesePizza;
import com.atguigu.factory.factorymethod.pizzastore.pizza.BJPepperPizza;
import com.atguigu.factory.factorymethod.pizzastore.pizza.Pizza;


/**
 * @author gcq
 * @Create 2020-09-30
 */
public class BJOrderPizza extends OrderPizza{

    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.atguigu.factory.factorymethod.pizzastore.order;

import com.atguigu.factory.factorymethod.pizzastore.pizza.*;
import com.sun.org.apache.bcel.internal.generic.LDC;


/**
 * @author gcq
 * @Create 2020-09-30
 */
public class LDOrderPizza extends OrderPizza{

    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new LDCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new LDPepperPizzza();
        }
        return pizza;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

6.3 抽象工厂模式

6.3.1基本介绍

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

6.3.2 抽象工厂模式应用实例

使用抽象工厂模式来完成披萨项目

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

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

/**
 * 一个抽象工厂的抽象层(接口)
 *
 * @author gcq
 * @Create 2020-09-30
 */
public interface AbsFactory {

    // 让下main的工厂子类来具体实现
    public Pizza createPizza(String orderType);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

OrderPizza.java

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

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

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

/**
 * @author gcq
 * @Create 2020-09-30
 */
public class OrderPizza {

    AbsFactory factory;

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

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

        do {
            orderType = gettype();
            // factory 可能是北京的工厂子类，也可能是伦敦的工厂子类
            pizza = factory.createPizza(orderType);
            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("订购失败");
                break;
            }
        } while (true);
    }
    //写一个方法 可以获取客户希望订购的披萨类
    private String gettype() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = strin.readLine();
            return str;
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

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

1、JDK 中 Calendar 类中，就使用到了简单工厂模式

2、源码+Debug源码+分析

package com.atguigu.jdk;

import java.util.Calendar;

/**
 * @author gcq
 * @Create 2020-09-30
 */
public class Factory {
    public static void main(String[] args) {
        //  getInstance 是 Calendar的静态方法
        Calendar instance = Calendar.getInstance();
        System.out.println("年:" + instance.get(Calendar.YEAR));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static Calendar getInstance()
{
    return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
}
1
2
3
4
private static Calendar createCalendar(TimeZone zone,
                                       Locale aLocale) // 根据TimeZone Local 创建对应的实例
{
    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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

上次更新: 2024/03/29, 08:56:31
单例设计模式
原型模式

← 原型模式→

最近更新
01
并行训练
03-29
02
tensor维度转换
03-26
03
ResNet源码解读
03-23
更多文章>
Theme by Vdoing | Copyright © 2022-2024 Geeks_Z | MIT License
京公网安备 11010802040735号 | 京ICP备2022029989号-1