>>>大话设计模式读书笔记系列目录>>>
工厂方法
定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
场景：
通过计算器（加减乘除）来讲解工厂方式
计算器运算抽象类
/**
* 计算器运算抽象类
*/
public abstract class Operation {
/**
* 操作数A
*/
private double numberA;
/**
* 操作数B
*/
private double numberB;
/**
* 抽象方法
* 获得操作结果
*
* @return
*/
public abstract double getResult();
/**
* 获取 操作数A
*
* @return numberA 操作数A
*/
public double getNumberA() {
return this.numberA;
}
/**
* 设置 操作数A
*
* @param numberA 操作数A
*/
public void setNumberA(double numberA) {
this.numberA = numberA;
}
/**
* 获取 操作数B
*
* @return numberB 操作数B
*/
public double getNumberB() {
return this.numberB;
}
/**
* 设置 操作数B
*
* @param numberB 操作数B
*/
public void setNumberB(double numberB) {
this.numberB = numberB;
}
@Override
public String toString() {
return "Operation{" +
"numberA=" + numberA +
", numberB=" + numberB +
'}';
}
}
加法运算类
/**
* 加法运算类
*/
public class OperationAdd extends Operation {
@Override
public double getResult() {
return super.getNumberA() + super.getNumberB();
}
}
减法运算类
/**
* 减法运算类
*/
public class OperationSub extends Operation {
@Override
public double getResult() {
return super.getNumberA() - super.getNumberB();
}
}
乘法运算类
/**
* 乘法运算类
*/
public class OperationMul extends Operation {
@Override
public double getResult() {
return super.getNumberA() * super.getNumberB();
}
}
除法运算类
/**
* 除法运算类
*/
public class OperationDiv extends Operation {
@Override
public double getResult() {
return super.getNumberA() / super.getNumberB();
}
}
工厂接口
/**
* 工厂接口
*/
public interface IFactory {
Operation createOperation();
}
加法工厂实现类
/**
* 加法工厂实现类
*/
public class AddFactory implements IFactory {
@Override
public Operation createOperation() {
return new OperationAdd();
}
}
减法工厂实现类
/**
* 减法工厂实现类
*/
public class SubFactory implements IFactory {
@Override
public Operation createOperation() {
return new OperationSub();
}
}
乘法工厂实现类
/**
* 乘法工厂实现类
*/
public class MulFactory implements IFactory {
@Override
public Operation createOperation() {
return new OperationMul();
}
}
除法工厂实现类
/**
* 除法工厂实现类
*/
public class DevFactory implements IFactory {
@Override
public Operation createOperation() {
return new OperationDiv();
}
}
调用
/**
* 部分代码参照简单工厂demo
* 工厂模式
*/
public class FactoryMethodDemo {
public static void main(String[] args) {
IFactory operFactory;
Operation oper;
double result;
//创建加法工厂
operFactory=new AddFactory();
//获得加法运算器
oper=operFactory.createOperation();
oper.setNumberA(1);
oper.setNumberB(2);
//获得结果
result=oper.getResult();
System.out.println("加法计算结果:"+String.valueOf(result));
//创建乘法工厂
operFactory=new MulFactory();
//获得加法运算器
oper=operFactory.createOperation();
oper.setNumberA(1);
oper.setNumberB(2);
//获得结果
result=oper.getResult();
System.out.println("乘法计算结果:"+String.valueOf(result));
//创建除法工厂
operFactory=new DevFactory();
//获得加法运算器
oper=operFactory.createOperation();
oper.setNumberA(1);
oper.setNumberB(2);
//获得结果
result=oper.getResult();
System.out.println("除法计算结果:"+String.valueOf(result));
//创建减法工厂
operFactory=new SubFactory();
//获得加法运算器
oper=operFactory.createOperation();
oper.setNumberA(1);
oper.setNumberB(2);
//获得结果
result=oper.getResult();
System.out.println("减法计算结果:"+String.valueOf(result));
}
}
结果
加法计算结果:3.0 乘法计算结果:2.0 除法计算结果:0.5 减法计算结果:-1.0
解析
简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖.
工厂方法模式实现时,客户端需要决定实例化哪一个工厂来实现运算类,选择判断的问题还是存在的,也就是说,工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行,你想要加功能,本来是改工厂类的,而现在是修改客户端.