Java方法重构实践：统一处理多类型参数的策略

// 原始方法示例 (简化)
public static String calculateAmount(QRequest qRequest) {
  if (qRequest.getValue() == null) { return "300_VALUE"; }
  // ... 核心逻辑
  return "RESULT";
}

public static String calculateAmount(CState cState) {
  if (cState.getValue() == null) { return "300_VALUE"; }
  // ... 核心逻辑
  return "RESULT";
}

public static String calculateAmount(RState rState) {
  if (rState.getValue() == null) { return "EXCESS_300_VALUE"; } // 注意此处的差异
  // ... 核心逻辑
  return "RESULT";
}

// 辅助定义：ValueType 是 QRequest, CState, RState 中 getValue() 返回的共同类型
class ValueType {
    private java.util.Set<Integer> optionalCodes;

    public ValueType() {
        this.optionalCodes = new java.util.HashSet<>();
    }

    public java.util.Set<Integer> getOptionalCodes() {
        return optionalCodes;
    }

    public void addOptionalCode(Integer code) {
        this.optionalCodes.add(code);
    }
}

// 辅助定义：自定义异常
class ServiceException extends RuntimeException {
    public ServiceException(String message) {
        super(message);
    }
}

// 定义常量
final class Constants {
    public static final String DEFAULT_300_VALUE = "300_VALUE";
    public static final String VALUE_125 = "125_VALUE";
    public static final String VALUE_600 = "600_VALUE";
    public static final int CODE_125 = 125;
    public static final int CODE_600 = 600;
}

// 步骤1: 定义通用接口
interface HasValue {
    ValueType getValue();
}

// 步骤2: 示例类实现接口
class QRequest implements HasValue {
    private ValueType value;
    public QRequest(ValueType value) { this.value = value; }
    @Override
    public ValueType getValue() { return value; }
}

class CState implements HasValue {
    private ValueType value;
    public CState(ValueType value) { this.value = value; }
    @Override
    public ValueType getValue() { return value; }
}

class RState implements HasValue {
    private ValueType value;
    public RState(ValueType value) { this.value = value; }
    @Override
    public ValueType getValue() { return value; }
}

// 步骤3: 重构后的单一方法
public class AmountCalculator {
    public static String calculateAmount(HasValue hasValue) {
        ValueType value = hasValue.getValue();

        // 逻辑与原始方法保持一致
        if (value == null) {
            // 注意：RState 在原问题中有一个不同的默认值。
            // 为了保持重构后的方法逻辑统一，这里假设默认值已标准化。
            return Constants.DEFAULT_300_VALUE;
        }

        if (value.getOptionalCodes().contains(Constants.CODE_125) &&
            value.getOptionalCodes().contains(Constants.CODE_600)) {
            throw new ServiceException("Multiple options received");
        }

        if (value.getOptionalCodes().contains(Constants.CODE_125)) {
            return Constants.VALUE_125;
        } else if (value.getOptionalCodes().contains(Constants.CODE_600)) {
            return Constants.VALUE_600;
        } else {
            return Constants.DEFAULT_300_VALUE;
        }
    }
}

// 辅助定义 (同上，不再重复列出 ValueType, ServiceException, Constants)

public class AmountCalculatorWithHelper {

    // 原始方法重构为调用辅助方法
    public static String calculateAmount(QRequest qRequest) {
        return calculateAmountHelper(qRequest.getValue());
    }

    public static String calculateAmount(CState cState) {
        return calculateAmountHelper(cState.getValue());
    }

    public static String calculateAmount(RState rState) {
        // 注意：RState 在原问题中有一个不同的默认值。
        // 为了保持辅助方法逻辑一致，这里假设其getValue()返回的ValueType处理逻辑相同。
        // 如果默认值确实需要差异化，则需要将默认值作为参数传递给helper或在调用前处理。
        return calculateAmountHelper(rState.getValue());
    }

    // 核心逻辑辅助方法 (通常设置为 private，除非需要外部直接调用)
    private static String calculateAmountHelper(ValueType value) {
        // 逻辑与原始方法保持一致
        if (value == null) {
            return Constants.DEFAULT_300_VALUE;
        }

        if (value.getOptionalCodes().contains(Constants.CODE_125) &&
            value.getOptionalCodes().contains(Constants.CODE_600)) {
            throw new ServiceException("Multiple options received");
        }

        if (value.getOptionalCodes().contains(Constants.CODE_125)) {
            return Constants.VALUE_125;
        } else if (value.getOptionalCodes().contains(Constants.CODE_600)) {
            return Constants.VALUE_600;
        } else {
            return Constants.DEFAULT_300_VALUE;
        }
    }
}