Java实现工厂方法模式

8.3 工厂方法模式实现

将之前简单工厂实现的计算器以工厂方法模式去实现。

结构图

先构建一个工厂接口

public interface IFactory {
    Operation createOperation();
}

加减乘除各建一个类去实现这个接口

//加法类工厂
class AddFactory implements IFactory {

    public Operation createOperation(){
        return new OperationAdd();
    }
}

//...类似

客户端

IFactory operFactory = new AddFactory();
Operation oper = operFactory.createOperation();
oper.setNumberA(1);
oper.setNumberB(2);
double result = oper.getResult();

8.4 简单工厂VS工厂方法

在简单工厂中，增加一个运算，先创建一个具体运算类实现运算接口，并在简单工厂中增加判断条件，加入这个新运算类。

工厂方法则是，增加运算类，再增加相关工厂类，再修改客户端，相当于复杂度增加，还添加了很多类和方法。

原先修改简单工厂中的方法，增加判断条件，修改原有类，违背开放-封闭原则。

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

问题：
客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在。
工厂方法把简单工厂内部逻辑判断移到了客户端代码来进行。
如果想要加功能，本来是改工厂类，现在修改客户端。

8.5 雷锋工厂

雷锋代表一种精神，可以帮助老人扫地、洗衣、买米等。
大学生可以是雷锋，志愿者也可以是雷锋。

//雷锋接口
public interface LeiFeng{
    public void sweep();

    public void wash();

    public void buyRice();
}

学雷锋的大学生/志愿者实现雷锋精神！

class ColleageStudent implements LeiFeng{
    //...实现三个类
}

//志愿者
class Volunteer implements LeiFeng{
    //...
}

简单雷锋工厂

public class SimpleFactory {
    public static LeiFeng createLeiFeng(String type){
        LeiFeng result = null;
        switch(type){
            case "大学生":
                result = new ColleageStudent();
                break;
            case "志愿者":
                result = new Volunteer();
                break;
            default:break;
        }
        return result;
    }
}

//客户端
LeiFeng studentA = SimpleFactory.createLeiFeng("大学生");
student.bugRice();

用工厂方法分拆SimpleFactory

interface IFactory{
    LeiFeng createLeiFeng();
}

//学雷锋的大学生工厂
class ColleageStudentFactory implements IFactory {
    public LeiFeng createLeiFeng(){
        return new ColleageStudent();
    }
}

//志愿者工厂
class VolunteerFactory implements IFactory {
    public LeiFeng createLeiFeng(){
        return new Volunteer();
    }
}

//客户端调用
IFacotry factory = new ColleageStudentFactory();
LeiFeng student = factory.createLeiFeng();

student.bugRice();
student.sweep();
student.wash();

缺点：每加一个产品，就加一个产品工厂的类，增加额外开发量。

避免修改客户端的代码方法：利用反射避免分支判断的问题。