如何在Java代码中泛化比较逻辑以避免重复代码？

你现在的问题是每个Filter实现类都要重复编写switch判断ComparisonStrategy的逻辑，导致代码冗余。这里有两个可行的方案来避免重复：

方案一：用抽象基类封装通用范围比较逻辑 #

把重复的策略判断逻辑抽到抽象基类里，子类只需要实现获取待比较数值的方法即可。

首先明确ComparisonStrategy枚举（补全供参考）：

public enum ComparisonStrategy {
    EXCLUSIVE, INCLUSIVE
}

创建抽象基类RangeFilter：

public abstract class RangeFilter implements Filter {
    private final double min;
    private final double max;
    private final ComparisonStrategy strategy;

    protected RangeFilter(double min, double max, ComparisonStrategy strategy) {
        this.min = min;
        this.max = max;
        this.strategy = strategy;
    }

    // 子类必须实现该方法，返回要和范围比较的地震属性值
    protected abstract double getTargetValue(Earthquake earthquake);

    @Override
    public boolean satisfies(Earthquake earthquake) {
        double targetValue = getTargetValue(earthquake);
        return switch (strategy) {
            case EXCLUSIVE -> targetValue > min && targetValue < max;
            case INCLUSIVE -> targetValue >= min && targetValue <= max;
        };
    }
}

简化后的MagnitudeFilter，无需重复编写switch：

public final class MagnitudeFilter extends RangeFilter {
    public MagnitudeFilter(double minimumMagnitude, double maximumMagnitude, ComparisonStrategy strategy) {
        super(minimumMagnitude, maximumMagnitude, strategy);
    }

    @Override
    protected double getTargetValue(Earthquake earthquake) {
        return earthquake.magnitude();
    }
}

后续新增其他范围类Filter（比如DepthFilter），只需继承基类实现取值方法：

public final class DepthFilter extends RangeFilter {
    public DepthFilter(double minDepth, double maxDepth, ComparisonStrategy strategy) {
        super(minDepth, maxDepth, strategy);
    }

    @Override
    protected double getTargetValue(Earthquake earthquake) {
        return earthquake.depth();
    }
}

方案二：把比较策略封装成独立的函数式接口 #

把不同策略的比较逻辑抽成函数，让Filter类直接复用，彻底消除重复的switch代码。

定义函数式接口封装范围比较逻辑：

@FunctionalInterface
public interface RangeChecker {
    boolean isInRange(double value, double min, double max);
}

给ComparisonStrategy枚举添加获取对应比较器的方法：

public enum ComparisonStrategy {
    EXCLUSIVE {
        @Override
        public RangeChecker getChecker() {
            return (value, min, max) -> value > min && value < max;
        }
    },
    INCLUSIVE {
        @Override
        public RangeChecker getChecker() {
            return (value, min, max) -> value >= min && value <= max;
        }
    };

    public abstract RangeChecker getChecker();
}

简洁版MagnitudeFilter实现，直接调用策略对应的比较器：

public final class MagnitudeFilter implements Filter {
    private final double minimumMagnitude;
    private final double maximumMagnitude;
    private final RangeChecker rangeChecker;

    public MagnitudeFilter(double minimumMagnitude, double maximumMagnitude, ComparisonStrategy strategy) {
        this.minimumMagnitude = minimumMagnitude;
        this.maximumMagnitude = maximumMagnitude;
        this.rangeChecker = strategy.getChecker();
    }

    @Override
    public boolean satisfies(Earthquake earthquake) {
        return rangeChecker.isInRange(earthquake.magnitude(), minimumMagnitude, maximumMagnitude);
    }
}

这种方案灵活性更高，后续新增比较策略只需在枚举中添加实现，所有Filter类均可直接复用。

方案选择建议 #

• 如果你的Filter大多是范围类比较，优先用抽象基类方案，代码最简洁，子类开发成本最低。
• 如果需要更灵活的扩展（比如未来要加非范围的比较策略），函数式接口方案更合适，耦合度更低。

内容的提问来源于stack exchange，提问作者Ryan