设计模式之简单工厂模式

优点

1
// 包含了必要的 `逻辑判断` 根据外部信息决定究竟应该创建那个具体类的对象。通过使用简单的工厂模式，用户无需了解对象如何创建的，只需要传入必要的信息就可以了

缺点

1
2
// 工厂类集中了所有实例的创建逻辑，违背了高内聚责任分配原则。随着系统中具体产品类不断增多，势必要不断修改工厂类，不易维护和扩展。也违背了开放封闭原则。
// 注：开放封闭原则：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。

例子

实现一个计算器

// 构建一个抽象父类

1
2
3
4
5
6
// Product 角色，所有实例所共有的公共接口
abstract class Operation {
    public int numA;
    public int numB;
    public abstract int GetResult();
}

// 构建实现类。具体产品角色，实现 Product 中的接口

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
// ConcreteProduct 角色，实现 Product 中的接口
class Add extends Operation {
    @Override
    public int GetResult() {
        return numA + numB;
    }
}

// ConcreteProduct 角色，实现 Product 中的接口
class Sub extends Operation {
    @Override
    public int GetResult() {
        return numA - numB;
    }
}

// ConcreteProduct 角色，实现 Product 中的接口
class Mul extends Operation {
    @Override
    public int GetResult() {
        return numA * numB;
    }
}

// ConcreteProduct 角色，实现 Product 中的接口
class Div extends Operation {
    @Override
    public int GetResult() {
        if (numB == 0) {
            System.out.println("ERROR!");
            return -1;
        }
        return numA / numB;
    }
}

// 工厂角色（核心）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 工厂角色，简单工厂模式的核心，它负责实现创建所有实例的内部逻辑
class OperationFactory {
    public static Operation CreateOperation (char operate) {
        Operation oper = null;
        switch(operate) {
        case '+':
            oper = new Add();
            break;
        case '-':
            oper = new Sub();
            break;
        case '*':
            oper = new Mul();
            break;
        case '/':
            oper = new Div();
            break;
        default:
            break;
        }
        return oper;
    }
}