设计模式 - 简单工厂模式

2019-02-25 16:09:58来源：博客园阅读 ()

定义：简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

以上定义主要的意思就是通过一个工厂对象来决定创建哪一种产品类的一个实例，以下是简单工厂模式的类图

可以看出，以上主要有三种类，一个是产品的接口(也可以为一个普通的类或者抽象类)，一个是具体的产品类，还有就是工厂类，其中工厂类中有个通过传入的产品类型来决定创建哪种产品类实例的方法。下面将类图转化为代码

产品接口

public interface Product {
    void use();
}

两个具体产品类

public class ProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

public class ProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

工厂类

public class Factory {

    public static final String PRODUCT_TYPE_A = "A";

    public static final String PRODUCT_TYPE_B = "B";

    public Product createProduct(String productType) {
        switch (productType) {
            case PRODUCT_TYPE_A:
                return new ProductA();
            case PRODUCT_TYPE_B:
                return new ProductB();
            default:
                throw new RuntimeException("输入的产品类型错误：" + productType);
        }
    }
}

测试类的调用和输出结果

Factory factory = new Factory();
Product a = factory.createProduct(Factory.PRODUCT_TYPE_A);
Product b = factory.createProduct(Factory.PRODUCT_TYPE_B);

a.use();
b.use();

Product error = factory.createProduct("error");
error.use();

通过以上的类图和代码，使我们了解了简单工厂模式的大致结构。下面通过实现一个简单的计算器功能来加深对该模式的理解，这个功能即通过输入的两个数字和一个计算符号来计算出最后的结果值，代码(未全部展示)如下

运算抽象类

public abstract class AbstractOperation {

    protected double numberA;

    protected double numberB;

    public abstract double getResult();
}

加减乘除四种运算类

public class OperationAdd extends AbstractOperation {
    @Override
    public double getResult() {
        return numberA + numberB;
    }
}

public class OperationSub extends AbstractOperation {
    @Override
    public double getResult() {
        return numberA - numberB;
    }
}

public class OperationMul extends AbstractOperation {
    @Override
    public double getResult() {
        return numberA * numberB;
    }
}

public class OperationDiv extends AbstractOperation {
    @Override
    public double getResult() {
        if (numberB == 0D) {
            throw new RuntimeException("除数不能为0");
        }
        return numberA / numberB;
    }
}

运算工厂类

public class OperationFactory {public AbstractOperation createOperation(String operationType) {
        switch (operationType) {
            case OPERATION_TYPE_ADD:
                return new OperationAdd();
            case OPERATION_TYPE_SUB:
                return new OperationSub();
            case OPERATION_TYPE_MUL:
                return new OperationMul();
            case OPERATION_TYPE_DIV:
                return new OperationDiv();
            default:
                throw new RuntimeException("输入的运算符号错误：" + operationType);
        }
    }
}

测试类的调用

OperationFactory of = new OperationFactory();
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数字A：");
double numberA = scanner.nextDouble();
System.out.println("请输入运算符号：");
String operationType = scanner.next();
System.out.println("请输入数字B：");
double numberB = scanner.nextDouble();
AbstractOperation operation = of.createOperation(operationType);
operation.setNumberA(numberA);
operation.setNumberB(numberB);
System.out.println(numberA + operationType + numberB + "=" + operation.getResult());