设计模式-工厂模式

简介

工厂模式是最常用的一类创建型设计模式，通常我们所说的工厂模式是指工厂方法模式，它也是使用频率最高的工厂模式。简单工厂模式是工厂方法模式的“小弟”，它不属于GoF 23种设计模式，但在软件开发中应用也较为频繁，通常将它作为学习其他工厂模式的入门。此外，工厂方法模式还有一位“大哥”——抽象工厂模式。这三种工厂模式各具特色，难度也逐个加大，在软件开发中它们都得到了广泛的应用，成为面向对象软件中常用的创建对象的工具。

简单工厂

定义

简单工厂模式(Simple Factory Pattern)：定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。因为在简单工厂模式中用于创建实例的方法是静态(static)方法，因此简单工厂模式又被称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。

角色

在简单工厂模式结构图中包含如下几个角色：

● Factory（工厂角色）：工厂角色即工厂类，它是简单工厂模式的核心，负责实现创建所有产品实例的内部逻辑；工厂类可以被外界直接调用，创建所需的产品对象；在工厂类中提供了静态的工厂方法factoryMethod()，它的返回类型为抽象产品类型Product。

● Product（抽象产品角色）：它是工厂类所创建的所有对象的父类，封装了各种产品对象的公有方法，它的引入将提高系统的灵活性，使得在工厂类中只需定义一个通用的工厂方法，因为所有创建的具体产品对象都是其子类对象。

● ConcreteProduct（具体产品角色）：它是简单工厂模式的创建目标，所有被创建的对象都充当这个角色的某个具体类的实例。每一个具体产品角色都继承了抽象产品角色，需要实现在抽象产品中声明的抽象方法。
示例
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
interface Car {
     void run();
}

public class BenchiCar implements Car {
    @Override
    public void run() {
        Log.d("kb_jay","BenchiCar run");
    }
}

public class BiyadiCar implements Car{

    @Override
    public void run() {
        Log.d("kb_jay","BiyadiCar run");
    }
}

public class SimpleFactory {
    public static final int TYPE_BENCHI = 1;
    public static final int TYPE_BIYADI = 2;

    public static Car createCar(int type) {
        Car car = null;
        switch (type) {
            case TYPE_BENCHI:
                car = new BenchiCar();
                break;
            case TYPE_BIYADI:
                car = new BiyadiCar();
                break;
            default:
                break;
        }
        return car;
    }
}

客户端测试代码如下

1
2
3
4
5
6
7
public class Client {
    public static void main(String[] args) {
       //1：简单工厂
        Car car = SimpleFactory.createCar(SimpleFactory.TYPE_BENCHI);
        car.run();
    }
}

运行结果如下

1
D/kb_jay: BenchiCar run

工厂方法

定义

定义一个用于创建对象的接口，让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。工厂方法模式又简称为工厂模式(Factory Pattern)，又可称作虚拟构造器模式(Virtual Constructor Pattern)或多态工厂模式(Polymorphic Factory Pattern)。工厂方法模式是一种类创建型模式。

工厂方法模式提供一个抽象工厂接口来声明抽象工厂方法，而由其子类来具体实现工厂方法，针对不同的产品提供不同的工厂。

角色

在工厂方法模式结构图中包含如下几个角色：

● Product（抽象产品）：它是定义产品的接口，是工厂方法模式所创建对象的超类型，也就是产品对象的公共父类。

● ConcreteProduct（具体产品）：它实现了抽象产品接口，某种类型的具体产品由专门的具体工厂创建，具体工厂和具体产品之间一一对应。

● Factory（抽象工厂）：在抽象工厂类中，声明了工厂方法(Factory Method)，用于返回一个产品。抽象工厂是工厂方法模式的核心，所有创建对象的工厂类都必须实现该接口。

● ConcreteFactory（具体工厂）：它是抽象工厂类的子类，实现了抽象工厂中定义的工厂方法，并可由客户端调用，返回一个具体产品类的实例。
示例
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
public interface Car {
    void run();

    class BiyadiCar implements Car{
        @Override
        public void run() {
            Log.d("kb_jay","biyadi run!!");
        }
    }
    class BenchiCar implements Car{

        @Override
        public void run() {
            Log.d("kb_jay","benchi run!!");
        }
    }
}

public interface CarFactory {
    Car createCar();

    class BenchiFactory implements CarFactory {
        @Override
        public Car createCar() {
            return new Car.BenchiCar();
        }
    }

    class BiyadiFatory implements CarFactory {
        @Override
        public Car createCar() {
            return new Car.BiyadiCar();
        }
    }

}

客户端测试代码如下

1
2
3
4

CarFactory carFactory = new CarFactory.BenchiFactory();
Car car1 = carFactory.createCar();
car1.run();

测试运行结果如下

1
D/kb_jay: benchi run!!

抽象工厂

定义

提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，它是一种对象创建型模式。

角色

在抽象工厂模式结构图中包含如下几个角色：

● AbstractFactory（抽象工厂）：它声明了一组用于创建一族产品的方法，每一个方法对应一种产品。

● ConcreteFactory（具体工厂）：它实现了在抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中。

● AbstractProduct（抽象产品）：它为每种产品声明接口，在抽象产品中声明了产品所具有的业务方法。

● ConcreteProduct（具体产品）：它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法。
示例
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

public interface Engine {
    void engine();

    class GoodEngine implements Engine{
        @Override
        public void engine() {
            Log.d("kb_jay","good engine!!!!");
        }
    }
    class BadEngine implements Engine{
        @Override
        public void engine() {
            Log.d("kb_jay","bad engine!!!!");
        }
    }
}

public interface LingjianFactory {
    Engine createEngine();
    Seater createSeater();


    class GoodLingjianFactory implements LingjianFactory{
        @Override
        public Engine createEngine() {
            return new Engine.GoodEngine();
        }

        @Override
        public Seater createSeater() {
            return new Seater.GoodSeater();
        }
    }

    class BadLingjianFactory implements LingjianFactory{
        @Override
        public Engine createEngine() {
            return new Engine.BadEngine();
        }

        @Override
        public Seater createSeater() {
            return new Seater.BadSeater();
        }
    }
}

public interface Seater {
    void seat();

    class GoodSeater implements Seater {
        @Override
        public void seat() {
            Log.d("kb_jay", "good seater!!!!");
        }
    }

    class BadSeater implements Seater {
        @Override
        public void seat() {
            Log.d("kb_jay", "bad Seater!!!!");
        }
    }
}

客户端测试代码如下

1
2
3
4
//3：抽象工厂
LingjianFactory lingjianFactory = new LingjianFactory.BadLingjianFactory();
Engine engine = lingjianFactory.createEngine();
engine.engine();

测试运行结果如下

1
D/kb_jay: bad engine!!!!

总结：

  1. 简单工厂（静态工厂）：

    抽象产品，不抽象工厂

    一个汽车工厂，生产多种car（一对多）

    我想买一辆奔驰，那么我就到这个厂里告诉它我想要奔驰（type），之后它就给我奔驰；

    朋羽毛想买一辆比亚迪，他同样到这个厂子里告诉老板，他想要比亚迪（type），那么老板就给他一辆比亚迪

  2. 工厂方法：

    抽象产品，也抽象工厂

    一个工厂对应一个产品（一对一） 我想买一辆奔驰，那么我到奔驰专卖店买；

    朋羽毛想买一辆比亚迪，那么她到比亚迪专卖店去买；

  3. 抽象工厂：

    抽象工厂，也抽象产品

    一个工厂对应一组不同但是相关的产品 产品簇，这些产品是相关的，

    比如：生产汽车零件的工厂