Java泛型抽象类中如何引用特定类型的随机范围函数？

我正在创建一个可处理Float和Integer值的泛型抽象类SelectionAlgorythm，核心需求是实现一个泛型随机范围选取函数。以下是我的示例代码及目标实现：

public abstract class SelectionAlgorythm < T > {
  protected static Random random = new Random();
  BiFunction < T, T, T > picker;

  RangePair pair;

  public abstract T value();

  protected SelectionAlgorythm(RangePair < T > pair) {
    this.pair = pair;
    if (pair.minRange instanceof Integer) {
      picker = SelectionAlgorythm::pickRandomInt;
    } else if (pair.minRange instanceof Float) {
      picker = SelectionAlgorythm::pickRandomFloat;
    }
  }

  private static Integer pickRandomInt(Integer val1, Integer val2) {
    return random.nextInt((int) val2 - (int) val1) + (int) val1;
  }

  private static Float pickRandomFloat(Float val1, Float val2) {
    return random.nextFloat() * (val2 - val1) + val1;
  }

  public T pickValue() {
    return picker.apply(pair.minRange, pair.maxRange);
  }
}

遇到的问题：

• picker的赋值语句提示“不兼容类型，T无法转换为Integer”；
• 无法直接将选取函数泛型化，因为random.nextInt()和random.nextFloat()需要特定类型的参数。

方案1：有界泛型+类型转换+抑制警告 #

先限制泛型T只能是Number的子类（Integer、Float均继承自Number），再通过强制转换解决方法引用的类型不匹配问题，同时抑制编译器的类型检查警告。

修改后的完整代码：

import java.util.Random;
import java.util.function.BiFunction;

public abstract class SelectionAlgorythm<T extends Number> {
    protected static Random random = new Random();
    BiFunction<T, T, T> picker;
    RangePair<T> pair;

    public abstract T value();

    @SuppressWarnings("unchecked")
    protected SelectionAlgorythm(RangePair<T> pair) {
        this.pair = pair;
        if (pair.minRange instanceof Integer) {
            picker = (BiFunction<T, T, T>) (BiFunction<Integer, Integer, Integer>) SelectionAlgorythm::pickRandomInt;
        } else if (pair.minRange instanceof Float) {
            picker = (BiFunction<T, T, T>) (BiFunction<Float, Float, Float>) SelectionAlgorythm::pickRandomFloat;
        } else {
            throw new IllegalArgumentException("不支持的类型：" + pair.minRange.getClass());
        }
    }

    private static Integer pickRandomInt(Integer val1, Integer val2) {
        int min = Math.min(val1, val2);
        int max = Math.max(val1, val2);
        return random.nextInt(max - min) + min;
    }

    private static Float pickRandomFloat(Float val1, Float val2) {
        float min = Math.min(val1, val2);
        float max = Math.max(val1, val2);
        return random.nextFloat() * (max - min) + min;
    }

    public T pickValue() {
        return picker.apply(pair.minRange, pair.maxRange);
    }

    // 补充RangePair的泛型定义
    static class RangePair<T extends Number> {
        T minRange;
        T maxRange;

        public RangePair(T minRange, T maxRange) {
            this.minRange = minRange;
            this.maxRange = maxRange;
        }
    }
}

说明：

• 用T extends Number限制泛型范围，确保只能传入数值类型；
• 两次强制转换将特定类型的方法引用转为泛型BiFunction，用@SuppressWarnings("unchecked")屏蔽警告；
• 优化随机函数，处理val1 > val2的边界情况，避免nextInt参数为负的异常。

方案2：策略模式拆分Picker实现 #

自定义Picker接口，为Integer和Float分别实现具体的选取逻辑，在构造函数中根据类型选择对应的Picker实例，避免泛型赋值冲突。

代码示例：

import java.util.Random;

public abstract class SelectionAlgorythm<T extends Number> {
    protected static Random random = new Random();
    Picker<T> picker;
    RangePair<T> pair;

    public abstract T value();

    protected SelectionAlgorythm(RangePair<T> pair) {
        this.pair = pair;
        if (pair.minRange instanceof Integer) {
            picker = (Picker<T>) new IntegerPicker();
        } else if (pair.minRange instanceof Float) {
            picker = (Picker<T>) new FloatPicker();
        } else {
            throw new IllegalArgumentException("不支持的类型：" + pair.minRange.getClass());
        }
    }

    // 定义Picker接口
    interface Picker<T> {
        T pick(T val1, T val2);
    }

    static class IntegerPicker implements Picker<Integer> {
        @Override
        public Integer pick(Integer val1, Integer val2) {
            int min = Math.min(val1, val2);
            int max = Math.max(val1, val2);
            return random.nextInt(max - min) + min;
        }
    }

    static class FloatPicker implements Picker<Float> {
        @Override
        public Float pick(Float val1, Float val2) {
            float min = Math.min(val1, val2);
            float max = Math.max(val1, val2);
            return random.nextFloat() * (max - min) + min;
        }
    }

    public T pickValue() {
        return picker.pick(pair.minRange, pair.maxRange);
    }

    static class RangePair<T extends Number> {
        T minRange;
        T maxRange;

        public RangePair(T minRange, T maxRange) {
            this.minRange = minRange;
            this.maxRange = maxRange;
        }
    }
}

说明：

• 用自定义接口替代BiFunction，每种数值类型对应独立的实现类，逻辑更清晰；
• 同样限制泛型范围为Number子类，保证类型安全。

方案3：直接在选取方法中做类型判断 #

去掉picker成员变量，直接在pickValue方法中判断类型并调用对应随机函数，避免泛型赋值的类型冲突问题。

代码示例：

import java.util.Random;

public abstract class SelectionAlgorythm<T extends Number> {
    protected static Random random = new Random();
    RangePair<T> pair;

    public abstract T value();

    protected SelectionAlgorythm(RangePair<T> pair) {
        this.pair = pair;
    }

    private Integer pickRandomInt(Integer val1, Integer val2) {
        int min = Math.min(val1, val2);
        int max = Math.max(val1, val2);
        return random.nextInt(max - min) + min;
    }

    private Float pickRandomFloat(Float val1, Float val2) {
        float min = Math.min(val1, val2);
        float max = Math.max(val1, val2);
        return random.nextFloat() * (max - min) + min;
    }

    @SuppressWarnings("unchecked")
    public T pickValue() {
        if (pair.minRange instanceof Integer) {
            Integer min = (Integer) pair.minRange;
            Integer max = (Integer) pair.maxRange;
            return (T) pickRandomInt(min, max);
        } else if (pair.minRange instanceof Float) {
            Float min = (Float) pair.minRange;
            Float max = (Float) pair.maxRange;
            return (T) pickRandomFloat(min, max);
        } else {
            throw new IllegalArgumentException("不支持的类型：" + pair.minRange.getClass());
        }
    }

    static class RangePair<T extends Number> {
        T minRange;
        T maxRange;

        public RangePair(T minRange, T maxRange) {
            this.minRange = minRange;
            this.maxRange = maxRange;
        }
    }
}

说明：

• 代码更简洁，直接在选取方法中完成类型判断和转换；
• 无需维护额外的成员变量，逻辑直观。

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