创建型设计模式-简单工厂与工厂方法设计模式

例子：比如输入两个数字，计算两个数字的加减乘除，然后打印结果

如果不使用工厂的方式

   @Test
    public void noFactory(){
        operation(8,9,"+");
    }
    
    public int  operation(int numA,int numB,String operation){
            switch (operation){
                case "+":
                    return numA+numB;
                case "-":
                    return numA-numB;
                case "*":
                    return numA*numB;
                case "/":
                    return numA/numB;
                default:
                    return 0;
            }
    }

operation这个方法里边进行了判断处理，这个方法里边耦合了具体的计算逻辑。

如果需要修改case中的一个某个算法，就可能会影响到其他的算法，怎么办呢？

下面来看下如果改成使用简单工厂的设计模式

//定义一个抽象类Operation
public abstract class Operation  {
    
    public double numberA;
    public double numberB;
    //定义一个抽象方法用于获取结果
    public abstract double getResult();
​
}
//加法
public class OperationAdd extends Operation {
​
    @Override
    public double getResult() {
        return numberA + numberB;
    }
}
​
//减法
public class OperationSub extends Operation {
    @Override
    public double getResult() {
        return numberA - numberB;
    }
}
​
//乘法
public class OperationMul extends Operation {
​
    @Override
    public double getResult() {
        return numberA * numberB;
    }
}
​
//除法
public class OperationDiv extends Operation {
​
    @Override
    public double getResult() {
        return numberA / numberB;
    }
}
//定义一个工厂
public class OperationFactory {
​
    public static Operation createOperation(String operation) {
        Operation op = null;
        switch (operation) {
            case "+":
                op = new OperationAdd();
                break;
            case "-":
                op = new OperationSub();
                break;
            case "*":
                op = new OperationMul();
                break;
            case "/":
                op = new OperationDiv();
                break;
            default:
                Log.e("lpf", "input operation is error");
                break;
        }
        return op;
    }
}
​
public class Client {
   @Test
    public void testFactory(){
        Operation operation = OperationFactory.createOperation("+");
        operation.numberA=10;
        operation.numberB=16;
        operation.getResult();
    }
}
​

我们来看下简单工厂的类图，有了类图方便理解和记忆。

简单工厂将算法部分封装到类里边了，那么如果想修改某个算法对其他的不会产生应用。

如果需要修改某个算法直接修改对应的类就可以，对其他的算法是没有影响。

那么如果我新增一个算法，就需要在工厂这个类新增一个case，按照开闭原则里的对修改关闭的原则，显然还是存在问题。怎么办呢？

我们继续对上面的简单工厂进行改造，使用工厂方法的设计模式

//定义一个抽象类Operation
public abstract class Operation  {
    
    public double numberA;
    public double numberB;
    //定义一个抽象方法用于获取结果
    public abstract double getResult();
​
}
//加法
public class OperationAdd extends Operation {
​
    @Override
    public double getResult() {
        return numberA + numberB;
    }
}
​
//减法
public class OperationSub extends Operation {
    @Override
    public double getResult() {
        return numberA - numberB;
    }
}
​
//乘法
public class OperationMul extends Operation {
​
    @Override
    public double getResult() {
        return numberA * numberB;
    }
}
​
//除法
public class OperationDiv extends Operation {
​
    @Override
    public double getResult() {
        return numberA / numberB;
    }
}
​
public interface IFactory {
    //抽象工厂，定义操作算法的接口
    Operation concreteOperation();
}
//加法工厂
public class FactoryAdd implements IFactory {
​
    @Override
    public Operation concreteOperation() {
        return new OperationAdd();
    }
}
//减法工厂
public class FactorySub implements IFactory {
​
    @Override
    public Operation concreteOperation() {
        return new OperationSub();
    }
}
//乘法工厂
public class FactoryMul implements IFactory{
    @Override
    public Operation concreteOperation() {
        return new OperationMul();
    }
}
//除法工厂
public class FactoryDiv implements IFactory {
​
    @Override
    public Operation concreteOperation() {
        return new OperationDiv();
    }
​
}
​
public class Client {
  @Test
    public void testFactoryMethod(){
         // 需要什么算法直接创建相应的算法工厂
        // 需求变更只需要需改某个算法类
        // 需求增加只需要相应的增加工厂和算法就可以扩展也很方便。
        IFactory factory=new FactoryAdd();
        Operation operation = factory.concreteOperation();
        operation.numberA=10;
        operation.numberB=16;
        operation.getResult();
    }
}

工厂方法的设计模式类图

使用工厂方法进行设计，使程序可扩展易维护。

工厂设计模式总结

• 工厂方法模式一种创建对象的模式

• 能够很好的封装方法细节

• 完美的体现了面向接口编程，体现了面向对象的思想。

• 编程是一门艺术，大批量的改动显然是非常丑陋的做法，用心的琢磨写的代码让它变的更美观。