设计模式-简单工厂模式

简单工厂模式的定义

简单工厂模式属于创建型设计模式，也可以叫做静态工厂模式，通过一个单独的工厂类负责对象的创建来实现 创建-使用的分离，同时，被创建的对类对象要实现相同的接口或继承相同的抽象类。

UML类图

以计算器Demo为例

简单工厂模式中主要包含四个角色：客户端、工厂、抽象接口、具体实现。
客户端：工厂的最终调用者。
工厂：简单工厂模式的核心，包含所有具体实现类的创建逻辑，是客户端和具体实现类的链接者。
抽象接口：可以是抽象类也可以是接口，描述了所有实现类的抽象，是工厂与具体实现类的联结者，是多态的体现。

简单工厂模式分析

• 简单工厂模式要解决的问题是如果创建合适的对象。
• 简单工厂模式的核心思想是用一个类来负责对象的具体创建工作
• 抽象接口与具体实现可能是多层级继承/实现的关系

代码实现(计算器)

/**
 * <h1>算法骨架</h1>
 * <p>
 *      每一种算法都要继承这个类，<br>
 *    并在getResult中实现具体的算法
 * </p>
 * */
public abstract class Operation {

    private double _numberA = 0;
    private double _numberB = 0;
    public double get_numberA() {
        return _numberA;
    }
    public void set_numberA(double _numberA) {
        this._numberA = _numberA;
    }
    public double get_numberB() {
        return _numberB;
    }
    public void set_numberB(double _numberB) {
        this._numberB = _numberB;
    }
    public abstract double getResult() throws Throwable;
}

/**
 * <h1>加法</h1>
 * */
public class AddOperation extends Operation {
    @Override
    public double getResult() {
        double result = 0;
        result = get_numberA() + get_numberB();
        return result;
    }
}

/**
 * <h1>减法</h1>
 * */
public class SubOperation extends Operation {
    @Override
    public double getResult() {
        double result = 0;
        result = get_numberA() - get_numberB();
        return result;
    }
}

/**
 * 乘法
 * */
public class MulOperation extends Operation {
    @Override
    public double getResult() {
        double result = 0;
        result = get_numberA() * get_numberB();
        return result;
    }
}

/**
 * <h1>除法</h1>
 * */
public class DivOperation extends Operation{
    @Override
    public double getResult() throws Exception {
        // TODO Auto-generated method stub
        double result = 0;
        if(get_numberB() == 0){
            throw new Exception("除数不能为0");
        }
        result = get_numberA() / get_numberB();
        return result;
    }
}

/***
 * 简单工厂创建代表具体算法的操作符类
 * */
public class OperationFactory {

    private OperationFactory(){}

    public static Operation createOperation(String opt){
        Operation operation = null;

        switch(opt){
           case "+" :
               operation = new AddOperation();
               break;
           case "-" :
               operation = new SubOperation();
               break;
           case "*" :
               operation = new MulOperation();
               break;
           case "/" :
               operation = new DivOperation();
               break;

        }
        return operation;
    }
}

public class Client {

    public static void main(String[] args) throws Throwable{
          Operation opt = null;
          opt = OperationFactory.createOperation("+");
          opt.set_numberA(5);
          opt.set_numberB(4);
          double result = opt.getResult();
          System.out.println(result);
    }
}

优点和缺点

在实践中，只有了解一样工具能做什么 不能做什么，才能应用的得心应手，设计模式亦是如此。
优点：

• 将对象的创建聚合到一个类中
• 通过工厂和抽象接口将具体实现接耦合
• 通过以上两种方式优化了代码结构

缺点：

• 当实现类超过一定数量时，工厂类会过于庞大，难以维护
• 违背了软件设计的开闭原则，及对扩展开放、对修改禁止，每当需要扩展时，都需要修改工厂类中的代码。
• 违背了软件设计的单一责任原则，工厂类即要负责判断创建何种对象，又要负责定义如何创建对象。

应用场景

JDBC接口与各个数据库厂商的驱动程序。