>>>大话设计模式读书笔记系列目录>>>

工厂方法

定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

场景：

通过计算器（加减乘除）来讲解工厂方式

 

 

计算器运算抽象类

/**
 * 计算器运算抽象类
 */
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

 

解析

简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖.

工厂方法模式实现时,客户端需要决定实例化哪一个工厂来实现运算类,选择判断的问题还是存在的,也就是说,工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行,你想要加功能,本来是改工厂类的,而现在是修改客户端.