工厂方法模式一种创建对象的模式，下面通过实际的例子来体会
例子：比如输入两个数字，计算两个数字的加减乘除，然后打印结果
如果不使用工厂的方式
@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();
}
}
我们来看下简单工厂的类图
image-20211229110855303.png
简单工厂将算法部分封装到类里边了，那么如果想修改某个算法对其他的不会产生应用。
如果需要修改某个算法直接修改对应的类就可以，对其他的算法是没有影响。
那么如果我新增一个算法，就需要在工厂这个类新增一个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();
}
}
工厂方法的设计模式类图
image-20211229185228642.png
工厂设计模式总结
- 工厂方法模式一种创建对象的模式
- 能够很好的封装方法细节
- 完美的体现了面向接口编程，体现了面向对象的思想。
- 编程是一门艺术，大批量的改动显然是非常丑陋的做法，用心的琢磨写的代码让它变的更美观。
网友评论