重构手法-消除相似接口实现类

原始代码

前期处理

相似性处理

return Integer.parseInt(arguments.get(index + 1));
return String.valueOf(arguments.get(index + 1));

提取差异代码为独立方法：
换成继承关系，可删除重复方法，并将差异方法改为protected可见性以支持重写，并调整返回值为Object。变成如下：

使用idea自带重构支持转函数式变量：

    @Override
    protected Object parseValue(String value) {
        Function<String, Integer> function = value1 -> Integer.parseInt(value1);
        return function.apply(value);
    }

进而转化为：

import java.util.function.Function;

class IntOptionParser extends StringOptionParser {
    Function<String, Integer> function = value1 -> Integer.parseInt(value1);

    @Override
    protected Object parseValue(String value) {
        return function.apply(value);
    }
}

函数式变量可简化：

 Function<String, Integer> function = Integer::parseInt;

两边代码同样处理，变成了只有变量不同，方法都相同的两个类：

为保留类添加构造函数：
另一个被消除类就变成了

class IntOptionParser extends StringOptionParser {
    public IntOptionParser() {
        super(Integer::parseInt);
    }
}

查看被消除类的方法在何处被使用：

替换成

new StringOptionParser(Integer::parseInt),

后，被消除类可被删除了。

继续优化被保留类：

1. 重命名更符合身份。
2. 同样的手法消除无参构造函数

class SingleValueOptionParser implements OptionParser {
    Function<String, Object> function;

    public SingleValueOptionParser(Function<String, Object> function) {
        this.function = function;
    }

    @Override
    public Object parse(List<String> arguments, String op) {
        int index = arguments.indexOf("-" + op);
        return function.apply(arguments.get(index + 1));
    }
}

再进行泛型处理：

class SingleValueOptionParser<T> implements OptionParser {
    Function<String, T> function;

    public SingleValueOptionParser(Function<String, T> function) {
        this.function = function;
    }

    @Override
    public T parse(List<String> arguments, String op) {
        int index = arguments.indexOf("-" + op);
        return function.apply(arguments.get(index + 1));
    }
}

            "p", new SingleValueOptionParser<>(Integer::parseInt),
            "d", new SingleValueOptionParser<>(String::valueOf));