具体详细聊一聊工厂设计模式

发表于 | 分类于
在基于类的编程中，工厂方法模式是一种创建模式，它使用工厂方法来处理创建对象的问题，而不必指定将要创建的对象的确切类...

1.工厂模式简介

In class-based programming, the factory method pattern is a creational pattern that uses factory methods to deal with the problem of creating objects without having to specify the exact class of the object that will be created. ( 在基于类的编程中，工厂方法模式是一种创建模式，它使用工厂方法来处理创建对象的问题，而不必指定将要创建的对象的确切类。) ——引用自维基百科

​ 通过上面的描述我们可以通过一个基类来创建多个子类，然后实现相应的方法，最后调用基类中的方法（工厂方法）来返回某个子类实例，并加以运用。这种方式增强了类的复用性和可扩展性。

K5dovR.png

2.工厂模式的类型

工厂模式主要有以下几种类型:

​ ①简单工厂模式：通过传入相关的类型来确切的返回相应的类,这种方式比较单 一,可扩展性相对较差;

②工厂方法模式：通过实现类实现相应的方法来决定相应的返回结果,这种方式的可扩展性比较强； ③抽象工厂方法模式：这个模式是以上模式的扩展，相比工厂方法而言，它所能生产的不只是一种产品，还可以是一组产品。
工厂模式的优点：
  • 解耦 ：把对象的创建和使用的过程分开
  • 降低代码重复: 如果创建某个对象的过程都很复杂，需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。
  • 降低维护成本 ：由于创建过程都由工厂统一管理，所以发生业务逻辑变化，不需要找到所有需要创建某个对象的地方去逐个修正，只需要在工厂里修改即可，降低维护成本。

3.相关实例

①简单工厂：

​ 这里我们举个简单的栗子，拿我们平时最常见的笔类来说，以此作为接口，含有书写的方法，分别有圆珠笔、铅笔、马克笔实现了笔类的接口。我们分别实现它的方法，描述一段话，然后我们根据简单工厂的方法得出每个书写的具体内容，也就是我们书写用的是什么类型的笔。

K5dRET.png

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
/**
 * 笔类接口
 */
interface Pen {
    void write();
}

/**
 * 圆珠笔
 */
class BallpointPen implements Pen {
    public void write() {
        System.out.println("书写:我是圆珠笔!");
    }
}

/**
 * 铅笔
 */
class Pencil implements Pen {
    public void write() {
        System.out.println("书写:我是铅笔!");
    }
}

/**
 * 马克笔
 */
class MarkerPen implements Pen {
    public void write() {
        System.out.println("书写:我是马克笔!");
    }
}

/**
 * 简单工厂
 */
class SimpleFactory {
    public Pen getPen(String type) {
        switch (type) {
            case "ballpointPen":
                return new BallpointPen();
            case "pencil":
                return new Pencil();
            case "markerPen":
                return new MarkerPen();
            default:
                return null;
        }
    }

}

public class PenWithType {

    public static void main(String[] args) {
        SimpleFactory simpleFactory = new SimpleFactory();
        Pen ballpointPen = simpleFactory.getPen("ballpointPen");
        ballpointPen.write();
        Pen pencil = simpleFactory.getPen("pencil");
        pencil.write();
        Pen markerPen = simpleFactory.getPen("markerPen");
        markerPen.write();
    }

}

输出结果：

1
2
3
书写:我是圆珠笔!
书写:我是铅笔!
书写:我是马克笔!
②工厂方法模式

​ 这个模式是使用最广泛的模式，通过子类来确定所需要创建的类型，每一个子类你都可以看做是一个小型工厂，可以生产一种产品，然后调用相应的方法。（如笔类工厂的相关类别：圆珠笔工厂、铅笔工厂、马克笔工厂等）还是拿我们上面的栗子进行变换，但是这次你会发现相比简单工厂而言，此种方法具有更多的可扩展性和复用性，同时也增强了代码的可读性。

K50s00.png

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
/**
 * 笔类工厂
 */
interface PenFactory {

    PenFactory getPen();

    void write();
}

/**
 * 圆珠笔工厂
 */
class BallpointPenFacTory implements PenFactory {
    public PenFactory getPen() {
        return new BallpointPenFacTory();
    }

    public void write() {
        System.out.println("书写:我是圆珠笔!");
    }
}

/**
 * 铅笔工厂
 */
class PencilFacTory implements PenFactory {
    public PenFactory getPen() {
        return new PencilFacTory();
    }

    public void write() {
        System.out.println("书写:我是铅笔!");
    }
}

/**
 * 马克笔工厂
 */
class MarkerPenFacTory implements PenFactory {
    public PenFactory getPen() {
        return new MarkerPenFacTory();
    }

    public void write() {
        System.out.println("书写:我是马克笔!");
    }
}

public class PenWithType {

    public static void main(String[] args) {
        BallpointPenFacTory ballpointPenFacTory = new BallpointPenFacTory();
        PenFactory penFactory = ballpointPenFacTory.getPen();
        penFactory.write();
    }

}

输出结果：

1
书写:我是圆珠笔!
③抽象工厂方法模式
这个是上面两种方式的扩展,这里我们不止可以创建一种笔，而是一组，可以说是将某个产品再细化下去。通俗的拿上面的例子来讲，铅笔需要笔杆和笔芯组装而成，我们再细化相应的实现，铁质的笔杆加上铅笔芯拼装起来最后得到铅笔。这个过程涉及到笔杆的实现类，笔芯的实现类，和铅笔工厂的实现类。

K5BI2Q.png

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
/*******************创建相关的接口*******************/

/**
 * 笔杆接口
 */
interface Penholder {
    void getMaterial();
}

/**
 * 笔芯接口
 */
interface Refill {
    void load();
}

/*******************创建相关的实现类*******************/

class plastic implements Penholder {
    @Override
    public void getMaterial() {
        System.out.println("我是塑料材质的笔杆");
    }
}

class iron implements Penholder {
    @Override
    public void getMaterial() {
        System.out.println("我是铁材质的笔杆");
    }
}

class PencilLeads implements Refill {
    @Override
    public void load() {
        System.out.println("装载铅笔芯");
    }
}

class InkCartridge implements Refill {
    @Override
    public void load() {
        System.out.println("装载油墨笔芯");
    }
}

/*******************创建工厂接口*******************/

interface Factory {

    Penholder producePenholder();

    Refill produceRefill();
}

/*******************创建工厂实现类*******************/

/**
 * 铅笔
 */
class PencilFactory implements Factory {

    @Override
    public Penholder producePenholder() {
        return new iron();
    }

    @Override
    public Refill produceRefill() {
        return new PencilLeads();
    }
}

/**
 * 圆珠笔
 */
class BallpointPenFactory implements Factory {

    @Override
    public Penholder producePenholder() {
        return new plastic();
    }

    @Override
    public Refill produceRefill() {
        return new InkCartridge();
    }
}


public class PenWithType {

    public static void main(String[] args) {
        // 这里我们创建一支铅笔
        Factory pencilFactory = new PencilFactory();
        Penholder penholder = pencilFactory.producePenholder();
        Refill refill = pencilFactory.produceRefill();
        penholder.getMaterial();
        refill.load();
    }
}

输出结果:

1
2
我是铁材质的笔杆
装载铅笔芯
城南少年与猫 wechat
欢迎您扫一扫订阅我的微信公众号！
0%