Design Patterns(二) Factory

backend

Factory pattern is one of the most used design patterns in Java. This type of design pattern comes under creational pattern as this pattern provides one of the best ways to create an object.

前言

    工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

简单工厂模式

介绍：

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

简单工厂模式结构图：


代码：

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
/**
 * @Auther: Arsenal
 * @Date: 2020-03-07 19:48
 * @Description: 简单工厂模式
 * JDK类库中广泛使用了简单工厂模式，如工具类java.text.DateFormat，它用于格式化一个本地日期或者时间。
 */
public class SimpleFactory {
    public static Computer createComputer(String brand) {
        Computer computer = null;
        switch (brand) {
            case "hp":
                computer = new Hp();
                break;
            case "dell":
                computer = new Dell();
                break;
            case "asus":
                computer = new Asus();
                break;
            default:
                computer = new Other();
        }
        return computer;
    }

    public static void main(String[] args) {
        SimpleFactory.createComputer("hp").start();
        SimpleFactory.createComputer("dell").start();
        SimpleFactory.createComputer("asus").start();
        SimpleFactory.createComputer("apple").start();

    }
}

interface Computer {
    void start();
}

class Hp implements Computer {

    @Override
    public void start() {
        System.out.println("惠普电脑启动了");
    }
}

class Dell implements Computer {

    @Override
    public void start() {
        System.out.println("戴尔电脑启动了");
    }
}

class Asus implements Computer {

    @Override
    public void start() {
        System.out.println("华硕电脑启动了");
    }
}

class Other implements Computer {

    @Override
    public void start() {
        System.out.println("杂牌电脑启动了");
    }
}

工厂方法模式

介绍：
1)工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品；

2)工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。首先完全实现‘开－闭 原则’，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的场合。

3)工厂方法模式对简单工厂模式进行了抽象。有一个抽象的Factory类（可以是抽象类和接口），这个类将不再负责具体的产品生产，而是只制定一些规范，具体的生产工作由其子类去完成。在这个模式中，工厂类和产品类往往可以依次对应。即一个抽象工厂对应一个抽象产品，一个具体工厂对应一个具体产品，这个具体的工厂就负责生产对应的产品。

4)工厂方法模式(Factory Method pattern)是最典型的模板方法模式(Template Method pattern)应用。

工厂方法模式结构图：


代码：

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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
/**
 * @Auther: Arsenal
 * @Date: 2020-03-09 18:49
 * @Description: 工厂方法模式
 */
public class MethodFactory {
    public static void main(String[] args) {
        ChineseFactory chineseFactory = new ChineseFactory();
        chineseFactory.newCar("Benz").start();
        chineseFactory.newCar("BWM").start();
        chineseFactory.newCar("Tesla").start();
        System.out.println("============");
        AmericaFactory americaFactory = new AmericaFactory();
        americaFactory.newCar("Tesla").start();
        americaFactory.newCar("Audi").start();
        americaFactory.newCar("Benz").start();
    }
}

interface Car {
    void start();
}

class Audi implements Car {

    @Override
    public void start() {
        System.out.println("奥迪启动");
    }
}

class BMW implements Car {

    @Override
    public void start() {
        System.out.println("宝马启动");
    }
}

class Benz implements Car {

    @Override
    public void start() {
        System.out.println("奔驰启动");
    }
}

class Tesla implements Car {

    @Override
    public void start() {
        System.out.println("特斯拉启动");
    }
}

class OtherCar implements Car {

    @Override
    public void start() {
        System.out.println("杂牌车启动");
    }
}

//工厂角色
abstract class Factory {
    /**
     * 让子类（具体工厂）来实例化具体对象（机器）
     */
    abstract Car newCar(String type);

    /**
     * 加工材料
     */
    void start(Car car) {
        car.start();
    }
}

class ChineseFactory extends Factory {

    @Override
    Car newCar(String type) {
        Car car = null;
        if ("BMW".equals(type)) {
            car = new BMW();
        } else if ("Benz".equals(type)) {
            car = new Benz();
        } else {
            car = new OtherCar();
        }
        return car;
    }
}

class AmericaFactory extends Factory {

    @Override
    Car newCar(String type) {
        Car car = null;
        if ("Tesla".equals(type)) {
            car = new Tesla();
        } else if ("Audi".equals(type)) {
            car = new Audi();
        } else {
            car = new OtherCar();
        }
        return car;
    }
}

抽象工厂模式

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

抽象工厂模式结构图：


代码：

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
86
87
88
89
90
91
/**
 * @Auther: Arsenal
 * @Date: 2020-03-09 20:03
 * @Description: 抽象工厂模式
 */
public class AbstractFactory {

    public static void main(String[] args) {
        Xiaomi xiaomi = new Xiaomi();
        xiaomi.createPhone().phoneInfo();
        xiaomi.createPad().padInfo();
        System.out.println("============");
        Apple apple = new Apple();
        apple.createPhone().phoneInfo();
        apple.createPad().padInfo();
    }

}

interface Phone {
    void phoneInfo();
}

interface Pad {
    void padInfo();
}

interface BrandFactory {
    Phone createPhone();

    Pad createPad();
}

class XiaomiPhone implements Phone {

    @Override
    public void phoneInfo() {
        System.out.println("生产小米手机");
    }
}

class XiaomiPad implements Pad {

    @Override
    public void padInfo() {
        System.out.println("生产小米平板");
    }
}


class ApplePhone implements Phone {

    @Override
    public void phoneInfo() {
        System.out.println("生产苹果手机");
    }
}

class ApplePad implements Pad {

    @Override
    public void padInfo() {
        System.out.println("生产苹果平板");
    }
}

class Xiaomi implements BrandFactory {

    @Override
    public Phone createPhone() {
        return new XiaomiPhone();
    }

    @Override
    public Pad createPad() {
        return new XiaomiPad();
    }
}

class Apple implements BrandFactory {

    @Override
    public Phone createPhone() {
        return new ApplePhone();
    }

    @Override
    public Pad createPad() {
        return new ApplePad();
    }
}

总结

工厂模式的意义：
1)将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性;
2) 三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式);
3) 设计模式的 依赖 抽象原则;
4) 创建对象实例时，不要直接 new 类, 而是把这个new 类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用;
5) 不要让类继承具体类，而是继承抽象类或者是实现interface(接口);
6) 不要覆盖基类中已经实现的方法。

延伸

    简单工厂模式
    工厂方法模式
    抽象工厂模式
    尚硅谷Java设计模式，韩顺平图解java设计模式

Article Title:Design Patterns(二) Factory

Article Author:Funing Ma

Release Time:2020-03-09 18:18:18

Last Update:2020-03-30 09:58:38

Original Link:https://mafuning.github.io/2020/03/09/2020-03-09-Design-Patterns%E3%80%90%E4%BA%8C%E3%80%91-Factory/

License Agreement: "CC-BY-SA-4.0"

Content
  1. 1. 前言
  2. 2. 简单工厂模式
  3. 3. 工厂方法模式
  4. 4. 抽象工厂模式
  5. 5. 总结
  6. 6. 延伸